From b4cf278522e7eaf298a668b8e9a90594b6d22a37 Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Thu, 29 Dec 2022 17:37:34 +1300
Subject: [PATCH 1/6] fix: Ran swiftformat to format code

---
 Package.swift                                 | 17 ++--
 .../OrderedDictionary+Dictionary.swift        |  6 +-
 Sources/Pioneer/Extensions/Expression.swift   |  2 +-
 .../Extensions/Futures/Actor+Task.swift       |  5 +-
 .../Extensions/Int/UInt64+Nanoseconds.swift   |  5 +-
 .../Pioneer/Extensions/Map/Map+Decoder.swift  |  4 +-
 .../Pioneer/Extensions/Pioneer+Graphiti.swift |  2 +-
 .../Extensions/Results/Data+Json.swift        |  2 +-
 Sources/Pioneer/GraphQL/BuiltinTypes.swift    | 25 +++--
 .../GraphQL/Extensions/Field+AsyncAwait.swift | 17 ++--
 .../Extensions/GraphQL+Execution.swift        |  5 +-
 .../Extensions/GraphQLError+Error.swift       |  6 +-
 Sources/Pioneer/GraphQL/GraphQLMessage.swift  |  8 +-
 Sources/Pioneer/GraphQL/GraphQLRequest.swift  | 21 ++--
 Sources/Pioneer/Http/HTTPGraphQL.swift        | 22 ++---
 Sources/Pioneer/Http/HttpStrategy.swift       |  8 +-
 Sources/Pioneer/Http/IDE.swift                | 43 ++++----
 Sources/Pioneer/Pioneer.swift                 | 59 ++++++-----
 .../Pioneer/Streaming/AsyncEventStream.swift  |  5 +-
 Sources/Pioneer/Streaming/AsyncPubSub.swift   | 27 +++--
 Sources/Pioneer/Streaming/Broadcast.swift     | 23 +++--
 ...syncEventStream+Future+GraphQLResult.swift | 14 +--
 .../Extension/AsyncSequence+EventStream.swift | 22 ++---
 .../Extension/AsyncStream+Statics.swift       | 16 +--
 .../Extension/EventStream+Static.swift        |  2 +-
 Sources/Pioneer/Streaming/PubSub.swift        |  6 +-
 Sources/Pioneer/Utils/Interval.swift          |  2 +-
 Sources/Pioneer/Utils/Timeout.swift           |  4 +-
 Sources/Pioneer/Utils/Validation.swift        | 16 +--
 .../CORS/CORSMIddleware+BananaCakePop.swift   |  8 +-
 .../CORS/CORSMiddleware+ApolloSandbox.swift   |  8 +-
 .../EnvironmentVariables.swift                |  6 +-
 .../GraphQLJSONEncoder+ContentEncoder.swift   |  6 +-
 .../Request/Request+GraphQLRequest.swift      | 23 ++---
 .../Request/Request+PathComponent.swift       | 28 +++---
 .../Request/Request+WebSocket.swift           |  6 +-
 .../Request/Request+WebsocketContext.swift    | 27 +++--
 .../Response/Response+GraphQLError.swift      |  8 +-
 .../WebSocket/WebSocket+WebSocketable.swift   |  2 +-
 Sources/Pioneer/Vapor/Http/Pioneer+Http.swift | 19 ++--
 Sources/Pioneer/Vapor/Http/Pioneer+IDE.swift  | 24 ++---
 .../Pioneer/Vapor/Pioneer+Standalone.swift    | 99 +++++++++----------
 .../Pioneer/Vapor/Pioneer+Vapor+Void.swift    | 20 ++--
 Sources/Pioneer/Vapor/Pioneer+Vapor.swift     | 69 +++++++------
 .../Vapor/WebSocket/Pioneer+WebSocket.swift   | 32 +++---
 .../Pioneer/WebSocket/Common/Payload.swift    |  2 +-
 .../Common/Pioneer+WebSocketable.swift        |  2 +-
 .../WebSocket/Common/WebSocketClient.swift    | 12 +--
 .../WebSocket/Common/WebSocketable.swift      |  6 +-
 .../Pioneer/WebSocket/Probe/Drone/Drone.swift | 42 ++++----
 Sources/Pioneer/WebSocket/Probe/Probe.swift   | 45 +++++----
 .../WebSocket/Protocol/GraphQLWs.swift        |  6 +-
 .../WebSocket/Protocol/SubProtocol.swift      |  4 +-
 .../Protocol/SubscriptionsTransportWs.swift   |  8 +-
 .../PioneerTests/ActorTests/DroneTests.swift  | 22 ++---
 .../PioneerTests/ActorTests/ProbeTests.swift  | 20 ++--
 .../DataStructureTests/AsyncPubSubTests.swift | 32 +++---
 .../BuiltInTypesTests.swift                   | 24 +++--
 .../WebSocketProtocolTests.swift              |  9 +-
 .../GraphitiAsyncEventStreamTests.swift       | 26 ++---
 .../GraphQLTests/GraphitiExtensionTests.swift |  5 +-
 .../GraphQLTests/PioneerStatelessTests.swift  | 19 ++--
 .../OtherTests/ExtensionsTests.swift          | 70 +++++++------
 .../OtherTests/SecurityTest.swift             | 24 ++---
 Tests/PioneerTests/Utils/TestConsumer.swift   |  5 +-
 .../VaporTests/ContextTests.swift             | 20 ++--
 .../VaporTests/HTTPQueryTests.swift           | 61 ++++++------
 .../VaporTests/HTTPStrategyTests.swift        | 89 ++++++++---------
 68 files changed, 649 insertions(+), 683 deletions(-)

diff --git a/Package.swift b/Package.swift
index 1e4ba26..4897f3e 100644
--- a/Package.swift
+++ b/Package.swift
@@ -6,20 +6,21 @@ import PackageDescription
 let package = Package(
     name: "Pioneer",
     platforms: [
-        .macOS(.v12)
+        .macOS(.v12),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(
             name: "Pioneer",
-            targets: ["Pioneer"]),
+            targets: ["Pioneer"]
+        ),
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
         // .package(url: /* package url */, from: "1.0.0"),
         .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "2.4.0"),
         .package(url: "https://github.com/GraphQLSwift/Graphiti.git", from: "1.2.1"),
-        .package(url: "https://github.com/vapor/vapor.git", from: "4.67.1")
+        .package(url: "https://github.com/vapor/vapor.git", from: "4.67.1"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -28,13 +29,15 @@ let package = Package(
             name: "Pioneer",
             dependencies: [
                 "GraphQL", "Graphiti",
-                .product(name: "Vapor", package: "vapor")
-            ]),
+                .product(name: "Vapor", package: "vapor"),
+            ]
+        ),
         .testTarget(
             name: "PioneerTests",
             dependencies: [
                 "Pioneer",
-                 .product(name: "XCTVapor", package: "vapor")
-            ]),
+                .product(name: "XCTVapor", package: "vapor"),
+            ]
+        ),
     ]
 )
diff --git a/Sources/Pioneer/Extensions/Collections/OrderedDictionary+Dictionary.swift b/Sources/Pioneer/Extensions/Collections/OrderedDictionary+Dictionary.swift
index 0c36674..f317133 100644
--- a/Sources/Pioneer/Extensions/Collections/OrderedDictionary+Dictionary.swift
+++ b/Sources/Pioneer/Extensions/Collections/OrderedDictionary+Dictionary.swift
@@ -7,11 +7,11 @@
 
 import struct OrderedCollections.OrderedDictionary
 
-extension OrderedDictionary {
+public extension OrderedDictionary {
     /// Turning OrderedDictionary into a regular one as both aren't API compatible.
-    public func unordered() -> [Key: Value] {
+    func unordered() -> [Key: Value] {
         var res = [Key: Value]()
-        forEach { (key, val) in
+        forEach { key, val in
             res[key] = val
         }
         return res
diff --git a/Sources/Pioneer/Extensions/Expression.swift b/Sources/Pioneer/Extensions/Expression.swift
index 1e20b49..29287d3 100644
--- a/Sources/Pioneer/Extensions/Expression.swift
+++ b/Sources/Pioneer/Extensions/Expression.swift
@@ -15,4 +15,4 @@ public func expression<ReturnType>(_ fn: () throws -> ReturnType) rethrows -> Re
 /// - Returns: The returned value of this closure
 public func expression<ReturnType>(_ fn: () async throws -> ReturnType) async rethrows -> ReturnType {
     try await fn()
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Extensions/Futures/Actor+Task.swift b/Sources/Pioneer/Extensions/Futures/Actor+Task.swift
index 1c72e6e..b79602f 100644
--- a/Sources/Pioneer/Extensions/Futures/Actor+Task.swift
+++ b/Sources/Pioneer/Extensions/Futures/Actor+Task.swift
@@ -5,14 +5,13 @@
 //  Created by d-exclaimation on 11:41 PM.
 //
 
-
-extension Actor {
+public extension Actor {
     /// Method for handling NIO EventLoopFuture with an Actor using the pipe pattern
     ///
     /// - Parameters:
     ///   - future: EventLoopFuture value being awaited
     ///   - to: Transforming callback to for the result from the Future.
-    public func pipeToSelf<U>(future: Task<U, Error>, to callback: @Sendable @escaping (Self, Result<U, Error>) async -> Void) {
+    func pipeToSelf<U>(future: Task<U, Error>, to callback: @Sendable @escaping (Self, Result<U, Error>) async -> Void) {
         Task {
             do {
                 let res = try await future.value
diff --git a/Sources/Pioneer/Extensions/Int/UInt64+Nanoseconds.swift b/Sources/Pioneer/Extensions/Int/UInt64+Nanoseconds.swift
index 8ff73ad..46487f3 100644
--- a/Sources/Pioneer/Extensions/Int/UInt64+Nanoseconds.swift
+++ b/Sources/Pioneer/Extensions/Int/UInt64+Nanoseconds.swift
@@ -20,11 +20,10 @@ public extension Optional where WrappedType == UInt64 {
         s * 1_000_000
     }
 
-    
     /// Convert the given value in microseconds into nanoseconds
     /// - Parameter s: The value in microseconds
     /// - Returns: The nanoseconds result
     static func microseconds(_ s: UInt64) -> UInt64 {
-        s * 1_000
+        s * 1000
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Extensions/Map/Map+Decoder.swift b/Sources/Pioneer/Extensions/Map/Map+Decoder.swift
index 0c152c9..e687dbc 100644
--- a/Sources/Pioneer/Extensions/Map/Map+Decoder.swift
+++ b/Sources/Pioneer/Extensions/Map/Map+Decoder.swift
@@ -5,8 +5,8 @@
 //  Created by d-exclaimation on 22:20.
 //
 
-import class Foundation.JSONEncoder
 import class Foundation.JSONDecoder
+import class Foundation.JSONEncoder
 import enum GraphQL.Map
 
 public extension Map {
@@ -27,4 +27,4 @@ public extension Payload {
         let data = try JSONEncoder().encode(self)
         return try JSONDecoder().decode(dataType, from: data)
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Extensions/Pioneer+Graphiti.swift b/Sources/Pioneer/Extensions/Pioneer+Graphiti.swift
index 06d6c01..f375f1b 100644
--- a/Sources/Pioneer/Extensions/Pioneer+Graphiti.swift
+++ b/Sources/Pioneer/Extensions/Pioneer+Graphiti.swift
@@ -42,7 +42,7 @@ public extension Pioneer {
             timeout: timeout
         )
     }
-    
+
     /// - Parameters:
     ///   - schema: GraphQL schema used to execute operations
     ///   - resolver: Resolver used by the GraphQL schema
diff --git a/Sources/Pioneer/Extensions/Results/Data+Json.swift b/Sources/Pioneer/Extensions/Results/Data+Json.swift
index a0463c7..378962b 100644
--- a/Sources/Pioneer/Extensions/Results/Data+Json.swift
+++ b/Sources/Pioneer/Extensions/Results/Data+Json.swift
@@ -10,7 +10,7 @@ import class Foundation.JSONDecoder
 
 extension Data {
     /// Parse data into any Decodable type if possible, otherwise return nil
-    func to<T: Decodable>(_ type: T.Type) -> T? {
+    func to<T: Decodable>(_: T.Type) -> T? {
         let decoder = JSONDecoder()
         decoder.dateDecodingStrategy = .iso8601
         return try? decoder.decode(T.self, from: self)
diff --git a/Sources/Pioneer/GraphQL/BuiltinTypes.swift b/Sources/Pioneer/GraphQL/BuiltinTypes.swift
index b1e776d..feabba3 100644
--- a/Sources/Pioneer/GraphQL/BuiltinTypes.swift
+++ b/Sources/Pioneer/GraphQL/BuiltinTypes.swift
@@ -6,15 +6,15 @@
 //
 
 import Foundation
-import GraphQL
 import Graphiti
+import GraphQL
 
 public typealias NoArgs = NoArguments
 
 /// The ID scalar type represents a unique identifier, often used to refetch an object or as the key for a cache.
 ///
 /// The ID type is serialized in the same way as a String; however, defining it as an ID signifies that it is not intended to be human‐readable.
-public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible, Hashable, Sendable {
+public struct ID: Codable, ExpressibleByStringLiteral, CustomStringConvertible, Hashable, Sendable {
     /// Inner string properties
     private var id: String
 
@@ -23,7 +23,7 @@ public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     }
 
     public init(uuid: UUID) {
-        self.id = uuid.uuidString
+        id = uuid.uuidString
     }
 
     public init(stringLiteral value: String) {
@@ -56,7 +56,7 @@ public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     /// Create a new ID from random letter
     public static func random(length: Int = 10) -> Self {
         let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-        let random = (0..<length).compactMap { _ in letters.randomElement() }
+        let random = (0 ..< length).compactMap { _ in letters.randomElement() }
         return .init(.init(random))
     }
 
@@ -64,7 +64,7 @@ public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     public var count: Int {
         id.count
     }
-    
+
     /// String value of this ID type
     public var string: String {
         id
@@ -78,7 +78,7 @@ public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     /// Get a UUID from this ID scalar
     /// - Returns: The UUID object if possible otherwise throw an error
     public func toUUID() throws -> UUID {
-        guard let uuid = self.uuid else {
+        guard let uuid = uuid else {
             throw ConversionError(id: id, reason: "Cannot convert this ID that is not in UUID string format to UUID")
         }
         return uuid
@@ -103,13 +103,12 @@ public struct ID : Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     }
 }
 
-
 public extension String {
     /// ID from this string
     var id: ID {
         .init(self)
     }
-    
+
     /// ID from this string
     func toID() -> ID {
         .init(self)
@@ -117,13 +116,13 @@ public extension String {
 }
 
 public extension UUID {
-        /// ID from this string
+    /// ID from this string
     var id: ID {
-        .init(self.uuidString)
+        .init(uuidString)
     }
-    
+
     /// ID from this string
     func toID() -> ID {
-        .init(self.uuidString)
+        .init(uuidString)
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/GraphQL/Extensions/Field+AsyncAwait.swift b/Sources/Pioneer/GraphQL/Extensions/Field+AsyncAwait.swift
index ee372a4..0752b2a 100644
--- a/Sources/Pioneer/GraphQL/Extensions/Field+AsyncAwait.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/Field+AsyncAwait.swift
@@ -6,8 +6,8 @@
 //
 
 import Graphiti
-import protocol NIO.EventLoopGroup
 import GraphQL
+import protocol NIO.EventLoopGroup
 
 /// Async-await non-throwing  GraphQL resolver function
 public typealias AsyncAwaitResolveWithEventLoop<ObjectType, Context, Arguments, FieldType> = (ObjectType) -> (Context, Arguments, EventLoopGroup) async -> FieldType
@@ -15,7 +15,7 @@ public typealias AsyncAwaitResolveWithEventLoop<ObjectType, Context, Arguments,
 /// Async-await throwing  GraphQL resolver function
 public typealias AsyncAwaitThrowingResolveWithEventLoop<ObjectType, Context, Arguments, FieldType> = (ObjectType) -> (Context, Arguments, EventLoopGroup) async throws -> FieldType
 
-public extension Graphiti.Field where FieldType : Encodable {
+public extension Graphiti.Field where FieldType: Encodable {
     // -- (context, args, eventLoop) async -> result
 
     convenience init(
@@ -44,7 +44,7 @@ public extension Graphiti.Field where FieldType : Encodable {
                 }
             }
         }
-        self.init(name, at: resolve, {})
+        self.init(name, at: resolve) {}
     }
 
     // -- (context, args, eventLoop) async throws -> result
@@ -75,12 +75,10 @@ public extension Graphiti.Field where FieldType : Encodable {
                 }
             }
         }
-        self.init(name, at: resolve, {})
+        self.init(name, at: resolve) {}
     }
-
 }
 
-
 public extension Graphiti.Field {
     // -- (context, args, eventLoop) async -> result
 
@@ -112,7 +110,7 @@ public extension Graphiti.Field {
                 }
             }
         }
-        self.init(name, at: resolve, as: `as`, {})
+        self.init(name, at: resolve, as: `as`) {}
     }
 
     // -- (context, args, eventLoop) async throws -> result
@@ -132,7 +130,7 @@ public extension Graphiti.Field {
         }
         self.init(name, at: resolve, as: `as`, argument)
     }
-    
+
     convenience init<ResolveType>(
         _ name: String,
         at function: @escaping AsyncAwaitThrowingResolveWithEventLoop<ObjectType, Context, Arguments, ResolveType>,
@@ -145,7 +143,6 @@ public extension Graphiti.Field {
                 }
             }
         }
-        self.init(name, at: resolve, as: `as`, {})
+        self.init(name, at: resolve, as: `as`) {}
     }
-
 }
diff --git a/Sources/Pioneer/GraphQL/Extensions/GraphQL+Execution.swift b/Sources/Pioneer/GraphQL/Extensions/GraphQL+Execution.swift
index db2f07f..ba8229e 100644
--- a/Sources/Pioneer/GraphQL/Extensions/GraphQL+Execution.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/GraphQL+Execution.swift
@@ -5,13 +5,11 @@
 //  Created by d-exclaimation on 9:46 PM.
 //
 
-
 import GraphQL
 import protocol NIO.EventLoopGroup
 
-
 /// Execute request-response based GraphQL Operation
-/// 
+///
 /// - Parameters:
 ///   - schema: GraphQL Schema used to execute request
 ///   - request: Query request string
@@ -42,7 +40,6 @@ public func executeGraphQL(
     ).get()
 }
 
-
 /// Execute streaming based GraphQL Operation
 ///
 /// - Parameters:
diff --git a/Sources/Pioneer/GraphQL/Extensions/GraphQLError+Error.swift b/Sources/Pioneer/GraphQL/Extensions/GraphQLError+Error.swift
index 873b400..cc693f8 100644
--- a/Sources/Pioneer/GraphQL/Extensions/GraphQLError+Error.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/GraphQLError+Error.swift
@@ -7,9 +7,9 @@
 
 import struct GraphQL.GraphQLError
 
-extension Error {
+public extension Error {
     /// Get the GraphQLError version of this error
-    public var graphql: GraphQLError {
+    var graphql: GraphQLError {
         self as? GraphQLError ?? .init(self)
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/GraphQL/GraphQLMessage.swift b/Sources/Pioneer/GraphQL/GraphQLMessage.swift
index 2ca8d4e..40e8ee1 100644
--- a/Sources/Pioneer/GraphQL/GraphQLMessage.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLMessage.swift
@@ -27,11 +27,11 @@ public struct GraphQLMessage: Codable {
     static func from(type: String, id: String? = nil, _ gql: GraphQL.GraphQLResult) -> GraphQLMessage {
         let errors = parseError(gql.errors)
         switch (gql.data, errors) {
-        case (.some(let data), .some(let errors)):
+        case let (.some(data), .some(errors)):
             return .init(id: id, type: type, payload: ["data": data, "errors": errors])
-        case (.some(let data), .none):
+        case let (.some(data), .none):
             return .init(id: id, type: type, payload: ["data": data])
-        case (.none, .some(let errors)):
+        case let (.none, .some(errors)):
             return .init(id: id, type: type, payload: ["errors": errors])
         case (.none, .none):
             return .init(id: id, type: type)
@@ -76,6 +76,6 @@ extension Encodable {
 
     /// Any encodable into JSON String otherwise null is returned
     var jsonString: String {
-        json.flatMap { String(data: $0, encoding: .utf8)} ?? "null"
+        json.flatMap { String(data: $0, encoding: .utf8) } ?? "null"
     }
 }
diff --git a/Sources/Pioneer/GraphQL/GraphQLRequest.swift b/Sources/Pioneer/GraphQL/GraphQLRequest.swift
index d6eff5b..57bc440 100644
--- a/Sources/Pioneer/GraphQL/GraphQLRequest.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLRequest.swift
@@ -42,27 +42,26 @@ public struct GraphQLRequest: Codable {
             let variables = try container.decodeIfPresent([String: Map]?.self, forKey: .variables)
             let extensions = try container.decodeIfPresent([String: Map]?.self, forKey: .extensions)
             self.init(
-                query: query, 
-                operationName: operationName ?? nil, 
-                variables: variables ?? nil, 
+                query: query,
+                operationName: operationName ?? nil,
+                variables: variables ?? nil,
                 extensions: extensions ?? nil
             )
         } catch {
             throw ParsingIssue.invalidForm
         }
     }
-    
 
     public init(
-        query: String, 
-        operationName: String? = nil, 
+        query: String,
+        operationName: String? = nil,
         variables: [String: Map]? = nil,
-        extensions: [String: Map]? = nil
+        extensions _: [String: Map]? = nil
     ) {
         self.query = query
         self.operationName = operationName
         self.variables = variables
-        self.ast = try? parse(source: .init(body: query))
+        ast = try? parse(source: .init(body: query))
     }
 
     public func encode(to encoder: Encoder) throws {
@@ -71,7 +70,7 @@ public struct GraphQLRequest: Codable {
         try container.encodeIfPresent(operationName, forKey: .operationName)
         try container.encodeIfPresent(variables, forKey: .variables)
         try container.encodeIfPresent(extensions, forKey: .extensions)
-    }   
+    }
 
     /// Getting parsed operationType
     public var operationType: OperationType? {
@@ -80,11 +79,11 @@ public struct GraphQLRequest: Codable {
             .compactMap { def -> OperationDefinition? in
                 def as? OperationDefinition
             }
-            
+
         guard let operationName = operationName else {
             return operations.first?.operation
         }
-        
+
         return operations
             .first {
                 guard let name = $0.name?.value else { return false }
diff --git a/Sources/Pioneer/Http/HTTPGraphQL.swift b/Sources/Pioneer/Http/HTTPGraphQL.swift
index 826c9fe..4f65bb2 100644
--- a/Sources/Pioneer/Http/HTTPGraphQL.swift
+++ b/Sources/Pioneer/Http/HTTPGraphQL.swift
@@ -5,16 +5,16 @@
 //  Created by d-exclaimation on 22:16.
 //
 
-import enum NIOHTTP1.HTTPResponseStatus
-import enum NIOHTTP1.HTTPMethod
+import struct GraphQL.GraphQLError
+import struct GraphQL.GraphQLResult
 import enum GraphQL.Map
 import struct NIOHTTP1.HTTPHeaders
-import struct GraphQL.GraphQLResult
-import struct GraphQL.GraphQLError
+import enum NIOHTTP1.HTTPMethod
+import enum NIOHTTP1.HTTPResponseStatus
 
-extension Pioneer {
+public extension Pioneer {
     /// HTTP-based GraphQL Response
-    public struct HTTPGraphQLResponse {
+    struct HTTPGraphQLResponse {
         /// GraphQL Result for this response
         public var result: GraphQLResult
 
@@ -33,11 +33,11 @@ extension Pioneer {
     }
 
     /// HTTP-based GraphQL request
-    public struct HTTPGraphQLRequest {
+    struct HTTPGraphQLRequest {
         /// GraphQL Request for this request
         public var request: GraphQLRequest
 
-        /// HTTP headers given in this request 
+        /// HTTP headers given in this request
         public var headers: HTTPHeaders
 
         /// HTTP method for this request
@@ -53,12 +53,12 @@ extension Pioneer {
             query: String,
             operationName: String? = nil,
             variables: [String: Map]? = nil,
-            headers: HTTPHeaders, 
-            method: HTTPMethod    
+            headers: HTTPHeaders,
+            method: HTTPMethod
         ) {
             self.request = .init(query: query, operationName: operationName, variables: variables)
             self.headers = headers
             self.method = method
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Http/HttpStrategy.swift b/Sources/Pioneer/Http/HttpStrategy.swift
index d8b7b92..2aecdad 100644
--- a/Sources/Pioneer/Http/HttpStrategy.swift
+++ b/Sources/Pioneer/Http/HttpStrategy.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 4:30 PM.
 //
 
-import enum NIOHTTP1.HTTPMethod
 import enum GraphQL.OperationType
+import enum NIOHTTP1.HTTPMethod
 
-extension Pioneer {
+public extension Pioneer {
     /// HTTP Operation and routing strategy for GraphQL
-    public enum HTTPStrategy {
+    enum HTTPStrategy {
         /// Only allow `POST` GraphQL Request, most common choice
         case onlyPost
         /// Only allow `GET` GraphQL Request, not recommended for most
@@ -25,7 +25,7 @@ extension Pioneer {
         case csrfPrevention
         /// Allow all operation through `GET` and `POST`.
         case both
-    
+
         /// Get the allowed operation for aa type of HTTPMethod
         /// - Parameter method: The HTTP Method this operation is executed
         /// - Returns: A list of allowed GraphQL Operation Type
diff --git a/Sources/Pioneer/Http/IDE.swift b/Sources/Pioneer/Http/IDE.swift
index 1ace49b..cd7b881 100644
--- a/Sources/Pioneer/Http/IDE.swift
+++ b/Sources/Pioneer/Http/IDE.swift
@@ -5,46 +5,45 @@
 //  Created by d-exclaimation on 14:17.
 //
 
-extension Pioneer {
+public extension Pioneer {
     /// GraphQL Hosted IDE
-    public enum IDE: Equatable {
+    enum IDE: Equatable {
         @available(*, deprecated, message: "Use `GraphiQL or Apollo Sandbox instead`")
         case playground
-        
+
         /// GraphiQL Browser IDE
         case graphiql
-        
+
         /// Embedded Apollo Sandbox
         case sandbox
-        
+
         /// Redirect to a cloud based IDE
         case redirect(to: Cloud)
-        
+
         /// Disabled any IDEs
         case disable
-        
+
         public enum Cloud {
             /// Cloud version of Apollo Sandbox
             case apolloSandbox
-            
+
             /// Cloud version of Banana Cake Pop
             case bananaCakePop
 
             /// URL for Cloud-based IDE
             public var url: String {
-                switch (self) {
-                    case .apolloSandbox:
-                        return "https://studio.apollographql.com/sandbox/explorer"
-                    case .bananaCakePop:
-                        return "https://eat.bananacakepop.com"
+                switch self {
+                case .apolloSandbox:
+                    return "https://studio.apollographql.com/sandbox/explorer"
+                case .bananaCakePop:
+                    return "https://eat.bananacakepop.com"
                 }
             }
         }
-
     }
-        
+
     /// GraphQL Playground HTML
-    public var playgroundHtml: String {
+    var playgroundHtml: String {
         let graphqlPlayground = """
         <!DOCTYPE html>
         <html>
@@ -115,7 +114,7 @@ extension Pioneer {
     }
 
     /// GraphiQL HTML
-    public var graphiqlHtml: String {
+    var graphiqlHtml: String {
         let fetcher: String = expression {
             switch websocketProtocol {
             case .subscriptionsTransportWs:
@@ -124,9 +123,9 @@ extension Pioneer {
                 <script>
                     const url = window.location.href;
                     const subscriptionUrl = window.location.href.replace("http", "ws");
-                
+
                     const legacyClient = new window.SubscriptionsTransportWs.SubscriptionClient(subscriptionUrl, { reconnect: true });
-                
+
                     const fetcher = GraphiQL.createFetcher({
                         url,
                         legacyClient,
@@ -229,9 +228,9 @@ extension Pioneer {
         </html>
         """
     }
-    
+
     /// Embedded Apollo Sandbox HTML
-    public var embeddedSandboxHtml: String {
+    var embeddedSandboxHtml: String {
         """
         <!DOCTYPE html>
         <html>
@@ -248,4 +247,4 @@ extension Pioneer {
         </html>
         """
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Pioneer.swift b/Sources/Pioneer/Pioneer.swift
index 724e9ae..8dffd03 100644
--- a/Sources/Pioneer/Pioneer.swift
+++ b/Sources/Pioneer/Pioneer.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 12:18 AM.
 //
 
-import NIO
 import Foundation
-import class GraphQL.GraphQLSchema
-import struct GraphQL.GraphQLResult
 import struct GraphQL.GraphQLError
+import struct GraphQL.GraphQLResult
+import class GraphQL.GraphQLSchema
 import enum GraphQL.OperationType
+import NIO
 
 /// Pioneer GraphQL Server for handling all GraphQL operations
 public struct Pioneer<Resolver, Context> {
@@ -26,7 +26,7 @@ public struct Pioneer<Resolver, Context> {
     public private(set) var introspection: Bool
     /// Allowing GraphQL IDE
     public private(set) var playground: IDE
-    /// Validation rules 
+    /// Validation rules
     public private(set) var validationRules: Validations
     /// Keep alive period
     public private(set) var keepAlive: UInt64?
@@ -70,7 +70,6 @@ public struct Pioneer<Resolver, Context> {
         self.keepAlive = keepAlive
         self.timeout = timeout
 
-
         let proto: SubProtocol.Type = expression {
             switch websocketProtocol {
             case .graphqlWs:
@@ -157,8 +156,7 @@ public struct Pioneer<Resolver, Context> {
         return .init(result: result, status: .ok)
     }
 
-
-    /// Handle messages that follow the websocket protocol for a specific client using Pioneer.Probe 
+    /// Handle messages that follow the websocket protocol for a specific client using Pioneer.Probe
     /// - Parameters:
     ///   - cid: The client key
     ///   - io: The client IO
@@ -168,15 +166,15 @@ public struct Pioneer<Resolver, Context> {
     ///   - txt: The message received
     ///   - context: The context builder for the client
     public func receiveMessage(
-        cid: UUID, 
+        cid: UUID,
         io: WebSocketable,
         keepAlive: Task<Void, Error>?,
-        timeout: Task<Void, Error>?, 
+        timeout: Task<Void, Error>?,
         ev: EventLoopGroup,
         txt: String,
         context: @escaping WebSocketContext,
         check: @escaping WebSocketGuard
-    ) async  {
+    ) async {
         guard let data = txt.data(using: .utf8) else {
             // Shouldn't accept any message that aren't utf8 string
             // -> Close with 1003 code
@@ -185,18 +183,17 @@ public struct Pioneer<Resolver, Context> {
         }
 
         switch websocketProtocol.parse(data) {
-
         // Initial sub-protocol handshake established
         // Dispatch process to probe so it can start accepting operations
         // Timer fired here to keep connection alive by sub-protocol standard
-        case .initial(let payload):
+        case let .initial(payload):
             do {
                 try await check(payload)
                 await initialiseClient(
-                    cid: cid, 
-                    io: io, 
-                    payload: payload, 
-                    timeout: timeout, 
+                    cid: cid,
+                    io: io,
+                    payload: payload,
+                    timeout: timeout,
                     ev: ev,
                     context: context
                 )
@@ -207,7 +204,7 @@ public struct Pioneer<Resolver, Context> {
                 // Deallocation of resources
                 await probe.disconnect(for: cid)
                 keepAlive?.cancel()
-                try? await io.terminate(code: .graphqlInvalid) 
+                try? await io.terminate(code: .graphqlInvalid)
             }
 
         // Ping is for requesting server to send a keep alive message
@@ -222,28 +219,28 @@ public struct Pioneer<Resolver, Context> {
             try? await io.terminate(code: .normalClosure)
 
         // Start -> Long running operation
-        case .start(oid: let oid, gql: let gql):
+        case let .start(oid: oid, gql: gql):
             await executeLongOperation(cid: cid, io: io, oid: oid, gql: gql)
 
         // Once -> Short lived operation
-        case .once(oid: let oid, gql: let gql):
+        case let .once(oid: oid, gql: gql):
             await executeShortOperation(cid: cid, io: io, oid: oid, gql: gql)
 
         // Stop -> End any running operation
-        case .stop(oid: let oid):
+        case let .stop(oid: oid):
             await probe.stop(
                 for: cid,
                 with: oid
             )
 
         // Error in validation should notify that no operation will be run, does not close connection
-        case .error(oid: let oid, message: let message):
+        case let .error(oid: oid, message: message):
             let err = GraphQLMessage.errors(id: oid, type: websocketProtocol.error, [.init(message: message)])
             io.out(err.jsonString)
 
         // Fatal error is an event trigger when message given in unacceptable by protocol standard
         // This message if processed any further will cause securities vulnerabilities, thus connection should be closed
-        case .fatal(message: let message):
+        case let .fatal(message: message):
             let err = GraphQLMessage.errors(type: websocketProtocol.error, [.init(message: message)])
             io.out(err.jsonString)
 
@@ -261,15 +258,15 @@ public struct Pioneer<Resolver, Context> {
     /// - Parameters:
     ///   - cid: The client key
     ///   - io: The client IO
-    ///   - payload: The initial connectionpayload 
+    ///   - payload: The initial connectionpayload
     ///   - timeout: The timeout interval for the client
     ///   - ev: Any event loop
     ///   - context: The context builder for the client
     public func initialiseClient(
-        cid: UUID, 
-        io: WebSocketable, 
-        payload: Payload, 
-        timeout: Task<Void, Error>?, 
+        cid: UUID,
+        io: WebSocketable,
+        payload: Payload,
+        timeout: Task<Void, Error>?,
         ev: EventLoopGroup,
         context: @escaping WebSocketContext
     ) async {
@@ -292,7 +289,7 @@ public struct Pioneer<Resolver, Context> {
         timeout?.cancel()
     }
 
-    /// Execute long-lived operation through Pioneer.Probe for a GraphQLRequest, context and get a well formatted GraphQlResult 
+    /// Execute long-lived operation through Pioneer.Probe for a GraphQLRequest, context and get a well formatted GraphQlResult
     /// - Parameters:
     ///   - cid: The client key
     ///   - io: The client IO for outputting errors
@@ -302,7 +299,7 @@ public struct Pioneer<Resolver, Context> {
         // Introspection guard
         guard allowed(from: gql) else {
             let err = GraphQLMessage.errors(id: oid, type: websocketProtocol.error, [
-                .init(message: "GraphQL introspection is not allowed by Pioneer, but the query contained __schema or __type.")
+                .init(message: "GraphQL introspection is not allowed by Pioneer, but the query contained __schema or __type."),
             ])
             return io.out(err.jsonString)
         }
@@ -319,7 +316,7 @@ public struct Pioneer<Resolver, Context> {
         )
     }
 
-    /// Execute short-lived operation through Pioneer.Probe for a GraphQLRequest, context and get a well formatted GraphQlResult 
+    /// Execute short-lived operation through Pioneer.Probe for a GraphQLRequest, context and get a well formatted GraphQlResult
     /// - Parameters:
     ///   - cid: The client key
     ///   - io: The client IO for outputting errors
@@ -329,7 +326,7 @@ public struct Pioneer<Resolver, Context> {
         // Introspection guard
         guard allowed(from: gql) else {
             let err = GraphQLMessage.errors(id: oid, type: websocketProtocol.error, [
-                .init(message: "GraphQL introspection is not allowed by Pioneer, but the query contained __schema or __type.")
+                .init(message: "GraphQL introspection is not allowed by Pioneer, but the query contained __schema or __type."),
             ])
             return io.out(err.jsonString)
         }
diff --git a/Sources/Pioneer/Streaming/AsyncEventStream.swift b/Sources/Pioneer/Streaming/AsyncEventStream.swift
index 5da2002..a1a175a 100644
--- a/Sources/Pioneer/Streaming/AsyncEventStream.swift
+++ b/Sources/Pioneer/Streaming/AsyncEventStream.swift
@@ -37,7 +37,7 @@ public final class AsyncEventStream<Element, Sequence: AsyncSequence>: EventStre
                 }
             }
 
-            continuation.onTermination = { @Sendable _ in 
+            continuation.onTermination = { @Sendable _ in
                 task.cancel()
             }
         }
@@ -59,6 +59,3 @@ public extension AsyncEventStream where Sequence == AsyncThrowingStream<Element,
         self.init(from: .init(elementType, bufferingPolicy: limit, build))
     }
 }
-
-
-
diff --git a/Sources/Pioneer/Streaming/AsyncPubSub.swift b/Sources/Pioneer/Streaming/AsyncPubSub.swift
index 69365e0..fef3c7b 100644
--- a/Sources/Pioneer/Streaming/AsyncPubSub.swift
+++ b/Sources/Pioneer/Streaming/AsyncPubSub.swift
@@ -8,14 +8,14 @@
 /// AsyncPubSub is a in memory pubsub structure for managing AsyncStreams in a concurrent safe way utilizing Actors.
 public struct AsyncPubSub: PubSub, Sendable {
     public typealias Producer = Broadcast<Sendable>
-    
+
     /// Dispatcher is a actor for the pubsub to concurrently manage publishers and incoming data
     public actor Dispatcher {
         private var emitters: [String: Producer] = [:]
-        
-        /// Subscribe get the emitters that is assigned to the given key 
+
+        /// Subscribe get the emitters that is assigned to the given key
         /// - Parameter key: The string topic / key used to differentiate emitters
-        /// - Returns: The emitters stored or a new one 
+        /// - Returns: The emitters stored or a new one
         internal func subscribe(for key: String) async -> Producer {
             let emitter = emitters.getOrElse(key) {
                 .init()
@@ -23,7 +23,7 @@ public struct AsyncPubSub: PubSub, Sendable {
             emitters.update(key, with: emitter)
             return emitter
         }
-        
+
         /// Async stream return a new AsyncStream that is connected to the emitter that is assigned to the given key
         /// - Parameter key: The string topic / key used to find the emitter
         /// - Returns: An async stream that is linked to an emitter
@@ -32,7 +32,7 @@ public struct AsyncPubSub: PubSub, Sendable {
             let downstream = await emitter.downstream()
             return downstream.stream
         }
-        
+
         /// Publish sends a data to a emitter that is assigned to the given key
         /// - Parameters:
         ///   - key: The string topic / key used to find the emitter
@@ -40,26 +40,25 @@ public struct AsyncPubSub: PubSub, Sendable {
         internal func publish(for key: String, _ value: Sendable) async {
             await emitters[key]?.publish(value)
         }
-        
+
         /// Close shutdowns an emitter that is assigned to the given key
         /// - Parameter key: The string / topic key
         internal func close(for key: String) async {
             await emitters[key]?.close()
             emitters.delete(key)
         }
-        
     }
-    
+
     public let dispatcher: Dispatcher = .init()
-    
+
     public init() {}
-    
+
     /// Returns a new AsyncStream with the correct type and for a specific trigger
     ///
     /// - Parameters:
     ///   - type: DataType of this AsyncStream
     ///   - trigger: The topic string used to differentiate what data should this stream be accepting
-    public func asyncStream<DataType: Sendable & Decodable>(_ type: DataType.Type = DataType.self, for trigger: String) -> AsyncStream<DataType> {
+    public func asyncStream<DataType: Sendable & Decodable>(_: DataType.Type = DataType.self, for trigger: String) -> AsyncStream<DataType> {
         AsyncStream<DataType> { con in
             let task = Task {
                 let pipe = await dispatcher.asyncStream(for: trigger)
@@ -74,7 +73,7 @@ public struct AsyncPubSub: PubSub, Sendable {
             }
         }
     }
-    
+
     /// Publish a new data into the pubsub for a specific trigger.
     /// - Parameters:
     ///   - trigger: The trigger this data will be published to
@@ -82,7 +81,7 @@ public struct AsyncPubSub: PubSub, Sendable {
     public func publish<DataType: Sendable & Encodable>(for trigger: String, payload: DataType) async {
         await dispatcher.publish(for: trigger, payload)
     }
-    
+
     /// Close a specific trigger and deallocate every consumer of that trigger
     /// - Parameter trigger: The trigger this call takes effect on
     public func close(for trigger: String) async {
diff --git a/Sources/Pioneer/Streaming/Broadcast.swift b/Sources/Pioneer/Streaming/Broadcast.swift
index a4548c6..1a8d42e 100644
--- a/Sources/Pioneer/Streaming/Broadcast.swift
+++ b/Sources/Pioneer/Streaming/Broadcast.swift
@@ -1,5 +1,5 @@
 //  Broadcast.swift
-//  
+//
 //
 //  Created by d-exclaimation on 20/06/22.
 //
@@ -9,9 +9,9 @@ import struct Foundation.UUID
 /// An actor to broadcast messages to multiple downstream from a single upstream
 public actor Broadcast<MessageType: Sendable> {
     public typealias Consumer = AsyncStream<MessageType>.Continuation
-    
+
     private var consumers: [UUID: Consumer] = [:]
-    
+
     /// Pipe an AsyncSequence to this broadcast and return the task is used to consume it
     /// - Parameter stream: The AsyncSequence used to push messages
     /// - Returns: The Task used to consumed it
@@ -23,7 +23,7 @@ public actor Broadcast<MessageType: Sendable> {
             await self.close()
         }
     }
-    
+
     /// Creates a new downstream with an id
     /// - Returns: The async stream and its id
     public func downstream() async -> Downstream<MessageType> {
@@ -31,7 +31,7 @@ public actor Broadcast<MessageType: Sendable> {
             Task {
                 await self.subscribe(id, with: con)
             }
-            
+
             con.onTermination = { @Sendable _ in
                 Task {
                     await self.unsubscribe(id)
@@ -39,19 +39,19 @@ public actor Broadcast<MessageType: Sendable> {
             }
         }
     }
-    
+
     /// Unsubscribe removed the downstream and prevent it from receiving any further broadcasted data
     /// - Parameter downstream: The key used to identified the consumer
     internal func unsubscribe(_ downstream: Downstream<MessageType>) async {
         consumers.delete(downstream.id)
     }
-    
+
     /// Unsubscribe removed the downstream and prevent it from receiving any further broadcasted data
     /// - Parameter id: The key used to identified the consumer
     internal func unsubscribe(_ id: UUID) async {
         consumers.delete(id)
     }
-    
+
     /// Subscribe saved and set up downstream to receive broadcasted message
     /// - Parameters:
     ///   - id: The key used to identified the consumer
@@ -60,7 +60,6 @@ public actor Broadcast<MessageType: Sendable> {
         consumers.update(id, with: downstream)
     }
 
-    
     /// Publish broadcast sendable data to all currently saved consumer
     /// - Parameter value: The sendable data to be published
     public func publish(_ value: MessageType) async {
@@ -68,7 +67,7 @@ public actor Broadcast<MessageType: Sendable> {
             consumer.yield(value)
         }
     }
-    
+
     /// Close shutdowns the entire broadcast and unsubscribe all consumer
     public func close() async {
         consumers.values.forEach { consumer in
@@ -86,7 +85,7 @@ public struct Downstream<Element: Sendable>: AsyncSequence {
     public let id: UUID
     /// The stream itself
     public let stream: AsyncStream<Element>
-    
+
     public init(
         _ elementType: Element.Type = Element.self,
         bufferingPolicy limit: AsyncStream<Element>.Continuation.BufferingPolicy = .unbounded,
@@ -98,7 +97,7 @@ public struct Downstream<Element: Sendable>: AsyncSequence {
             build(id, con)
         }
     }
-    
+
     public func makeAsyncIterator() -> AsyncStream<Element>.AsyncIterator {
         stream.makeAsyncIterator()
     }
diff --git a/Sources/Pioneer/Streaming/Extension/AsyncEventStream+Future+GraphQLResult.swift b/Sources/Pioneer/Streaming/Extension/AsyncEventStream+Future+GraphQLResult.swift
index f0695df..d389f93 100644
--- a/Sources/Pioneer/Streaming/Extension/AsyncEventStream+Future+GraphQLResult.swift
+++ b/Sources/Pioneer/Streaming/Extension/AsyncEventStream+Future+GraphQLResult.swift
@@ -5,21 +5,21 @@
 //  Created by d-exclaimation on 3:38 PM.
 //
 
-import struct GraphQL.GraphQLResult
 import class GraphQL.ConcurrentEventStream
 import class GraphQL.Future
+import struct GraphQL.GraphQLResult
 import class GraphQL.SubscriptionEventStream
 
 /// AsyncSequence for GraphQL Result
 public typealias AsyncGraphQLSequence<Sequence: AsyncSequence> = AsyncEventStream<Future<GraphQL.GraphQLResult>, Sequence>
-        where Sequence.Element == Future<GraphQL.GraphQLResult>
+    where Sequence.Element == Future<GraphQL.GraphQLResult>
 
 /// AsyncStream for GraphQL Result
 public typealias AsyncGraphQLStream = AsyncGraphQLSequence<AsyncThrowingStream<Future<GraphQL.GraphQLResult>, Error>>
 
-extension SubscriptionEventStream {
+public extension SubscriptionEventStream {
     /// Get the AsyncStream from this event stream regardless of its sequence
-    public func asyncStream() -> AsyncThrowingStream<Future<GraphQL.GraphQLResult>, Error>? {
+    func asyncStream() -> AsyncThrowingStream<Future<GraphQL.GraphQLResult>, Error>? {
         if let asyncStream = self as? AsyncGraphQLStream {
             return asyncStream.sequence
         }
@@ -30,7 +30,7 @@ extension SubscriptionEventStream {
     }
 }
 
-extension AsyncSequence where Element == Future<GraphQL.GraphQLResult> {
+public extension AsyncSequence where Element == Future<GraphQL.GraphQLResult> {
     /// Pipe the GraphQLResult AsyncSequence into an actor.
     ///
     /// - Parameters:
@@ -39,7 +39,7 @@ extension AsyncSequence where Element == Future<GraphQL.GraphQLResult> {
     ///   - error: A callback ran when an error were thrown when reading elements from this sequence.
     ///   - next: A callback ran on each element of this sequence.
     /// - Returns: The Task used to consume this AsyncSequence
-    public func pipe<ActorType: Actor>(
+    func pipe<ActorType: Actor>(
         to sink: ActorType,
         complete: @Sendable @escaping (ActorType) async -> Void,
         failure: @Sendable @escaping (ActorType, Error) async -> Void,
@@ -59,4 +59,4 @@ extension AsyncSequence where Element == Future<GraphQL.GraphQLResult> {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Streaming/Extension/AsyncSequence+EventStream.swift b/Sources/Pioneer/Streaming/Extension/AsyncSequence+EventStream.swift
index 781674b..d7fbf8a 100644
--- a/Sources/Pioneer/Streaming/Extension/AsyncSequence+EventStream.swift
+++ b/Sources/Pioneer/Streaming/Extension/AsyncSequence+EventStream.swift
@@ -7,13 +7,13 @@
 
 import class GraphQL.EventStream
 
-extension AsyncSequence {
-    public typealias Termination = AsyncThrowingStream<Element, Error>.Continuation.Termination
-    
+public extension AsyncSequence {
+    typealias Termination = AsyncThrowingStream<Element, Error>.Continuation.Termination
+
     /// Convert Any AsyncSequence to an EventStream for GraphQL Streaming.
     ///
     /// - Returns: EventStream implementation for AsyncSequence.
-    public func toEventStream() -> EventStream<Element> {
+    func toEventStream() -> EventStream<Element> {
         AsyncEventStream<Element, Self>(from: self)
     }
 
@@ -21,7 +21,7 @@ extension AsyncSequence {
     ///
     /// - Parameters:
     ///   - onTermination: onTermination callback
-    public func toEventStream(
+    func toEventStream(
         onTermination callback: @Sendable @escaping (Termination) -> Void
     ) -> EventStream<Element> {
         let stream = AsyncThrowingStream<Element, Error> { continuation in
@@ -48,13 +48,12 @@ extension AsyncSequence {
         return AsyncEventStream<Element, AsyncThrowingStream<Element, Error>>(from: stream)
     }
 
-
     /// Convert any AsyncSequence to an EventStream
     ///
     /// - Parameters:
     ///   - endValue: Ending value
     ///   - onTermination: onTermination callback
-    public func toEventStream(
+    func toEventStream(
         endValue: @escaping () -> Element,
         onTermination callback: @Sendable @escaping (Termination) -> Void
     ) -> EventStream<Element> {
@@ -83,13 +82,12 @@ extension AsyncSequence {
         return AsyncEventStream<Element, AsyncThrowingStream<Element, Error>>(from: stream)
     }
 
-
     /// Convert any AsyncSequence to an EventStream
     ///
     /// - Parameters:
     ///   - initialValue: Initial value from subscriptions
     ///   - onTermination: onTermination callback
-    public func toEventStream(
+    func toEventStream(
         initialValue: Element,
         onTermination callback: @Sendable @escaping (Termination) -> Void
     ) -> EventStream<Element> {
@@ -124,7 +122,7 @@ extension AsyncSequence {
     ///   - initialValue: Initial value from subscriptions
     ///   - endValue: Ending value
     ///   - onTermination: onTermination callback
-    public func toEventStream(
+    func toEventStream(
         initialValue: Element,
         endValue: @escaping () -> Element,
         onTermination callback: @Sendable @escaping (Termination) -> Void
@@ -154,13 +152,13 @@ extension AsyncSequence {
         }
         return AsyncEventStream<Element, AsyncThrowingStream<Element, Error>>(from: stream)
     }
-    
+
     /// Convert any AsyncSequence to an EventStream
     ///
     /// - Parameters:
     ///   - initialValue: Initial value from subscriptions
     ///   - endValue: Ending value
-    public func toEventStream(
+    func toEventStream(
         initialValue: Element,
         endValue: @escaping () -> Element
     ) -> EventStream<Element> {
diff --git a/Sources/Pioneer/Streaming/Extension/AsyncStream+Statics.swift b/Sources/Pioneer/Streaming/Extension/AsyncStream+Statics.swift
index c0575ff..d35f238 100644
--- a/Sources/Pioneer/Streaming/Extension/AsyncStream+Statics.swift
+++ b/Sources/Pioneer/Streaming/Extension/AsyncStream+Statics.swift
@@ -5,21 +5,21 @@
 //  Created by d-exclaimation on 10:05 PM.
 //
 
-extension AsyncStream {
+public extension AsyncStream {
     /// Create an AsyncStream from a single value
     /// - Parameter value: The only value in this stream
     /// - Returns: The AsyncStream itself
-    public static func just(_ value: Element) -> Self {
+    static func just(_ value: Element) -> Self {
         .init { con in
             con.yield(value)
             con.finish()
         }
     }
-    
+
     /// Create an AsyncStream from a certain amount of element
     /// - Parameter values: All the elements
     /// - Returns: The AsyncStream itself
-    public static func of(_ values: Element...) -> Self {
+    static func of(_ values: Element...) -> Self {
         .init { con in
             let task = Task {
                 values.forEach {
@@ -27,18 +27,18 @@ extension AsyncStream {
                 }
                 con.finish()
             }
-            
+
             con.onTermination = { @Sendable termination in
                 guard case .cancelled = termination else { return }
                 task.cancel()
             }
         }
     }
-    
+
     /// Create an AsyncStream from an iterable value
     /// - Parameter values: Iterable values
     /// - Returns: The AsyncStream itself
-    public static func iterable(_ values: [Element]) -> Self {
+    static func iterable(_ values: [Element]) -> Self {
         .init { con in
             let task = Task {
                 values.forEach {
@@ -46,7 +46,7 @@ extension AsyncStream {
                 }
                 con.finish()
             }
-            
+
             con.onTermination = { @Sendable termination in
                 guard case .cancelled = termination else { return }
                 task.cancel()
diff --git a/Sources/Pioneer/Streaming/Extension/EventStream+Static.swift b/Sources/Pioneer/Streaming/Extension/EventStream+Static.swift
index 88db2d8..c5f1a2e 100644
--- a/Sources/Pioneer/Streaming/Extension/EventStream+Static.swift
+++ b/Sources/Pioneer/Streaming/Extension/EventStream+Static.swift
@@ -13,7 +13,7 @@ public extension EventStream {
     ///   - elementType: The type of element the AsyncEventStream produces
     ///   - limit: The maximum number of elements to hold in the buffer
     ///   - build: A custom closure that yields values to the AsyncEventStream
-    static func `async`(
+    static func async(
         _ elementType: Element.Type = Element.self,
         bufferingPolicy limit: AsyncThrowingStream<Element, Error>.Continuation.BufferingPolicy = .unbounded,
         _ build: (AsyncThrowingStream<Element, Error>.Continuation) -> Void
diff --git a/Sources/Pioneer/Streaming/PubSub.swift b/Sources/Pioneer/Streaming/PubSub.swift
index 0e6c56c..e2d8301 100644
--- a/Sources/Pioneer/Streaming/PubSub.swift
+++ b/Sources/Pioneer/Streaming/PubSub.swift
@@ -1,5 +1,5 @@
 //  PubSub.swift
-//  
+//
 //
 //  Created by d-exclaimation on 20/06/22.
 //
@@ -12,13 +12,13 @@ public protocol PubSub {
     ///   - type: DataType of this AsyncStream
     ///   - trigger: The topic string used to differentiate what data should this stream be accepting
     func asyncStream<DataType: Sendable & Decodable>(_ type: DataType.Type, for trigger: String) -> AsyncStream<DataType>
-    
+
     /// Publish a new data into the pubsub for a specific trigger.
     /// - Parameters:
     ///   - trigger: The trigger this data will be published to
     ///   - payload: The data being emitted
     func publish<DataType: Sendable & Encodable>(for trigger: String, payload: DataType) async
-    
+
     /// Close a specific trigger and deallocate every consumer of that trigger
     /// - Parameter trigger: The trigger this call takes effect on
     func close(for trigger: String) async
diff --git a/Sources/Pioneer/Utils/Interval.swift b/Sources/Pioneer/Utils/Interval.swift
index 18fd719..de17b32 100644
--- a/Sources/Pioneer/Utils/Interval.swift
+++ b/Sources/Pioneer/Utils/Interval.swift
@@ -20,4 +20,4 @@
             try block()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Utils/Timeout.swift b/Sources/Pioneer/Utils/Timeout.swift
index af36ef4..713f82a 100644
--- a/Sources/Pioneer/Utils/Timeout.swift
+++ b/Sources/Pioneer/Utils/Timeout.swift
@@ -13,7 +13,7 @@
 @discardableResult public func setTimeout(delay: UInt64?, _ block: @Sendable @escaping () async throws -> Void) -> Task<Void, Error>? {
     guard let delay = delay else {
         return nil
-    } 
+    }
     return Task {
         try await Task.sleep(nanoseconds: delay)
         guard !Task.isCancelled else {
@@ -21,4 +21,4 @@
         }
         try await block()
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Utils/Validation.swift b/Sources/Pioneer/Utils/Validation.swift
index ea79d83..914376a 100644
--- a/Sources/Pioneer/Utils/Validation.swift
+++ b/Sources/Pioneer/Utils/Validation.swift
@@ -10,10 +10,10 @@ import GraphQL
 /// Function that describe a validation rule for an operation
 public typealias ValidationRule = (ValidationContext) -> Visitor
 
-extension Pioneer {
+public extension Pioneer {
     /// Validation strategy to add custom rules that is executed before any resolver is executed
-    public enum Validations: @unchecked Sendable, ExpressibleByArrayLiteral, ExpressibleByNilLiteral {
-        public init(nilLiteral: ()) {
+    enum Validations: @unchecked Sendable, ExpressibleByArrayLiteral, ExpressibleByNilLiteral {
+        public init(nilLiteral _: ()) {
             self = .none
         }
 
@@ -32,14 +32,14 @@ extension Pioneer {
 
         public func callAsFunction(using schema: GraphQLSchema, for gql: GraphQLRequest) -> [GraphQLError] {
             guard let ast = gql.ast else { return [] }
-            switch (self) {
+            switch self {
             case .none:
                 return []
-            case .specified(let rules):
+            case let .specified(rules):
                 return validate(schema: schema, ast: ast, rules: rules)
-            case .computed(let compute):
+            case let .computed(compute):
                 return validate(schema: schema, ast: ast, rules: compute(gql))
             }
         }
-    }    
-}
\ No newline at end of file
+    }
+}
diff --git a/Sources/Pioneer/Vapor/Extensions/CORS/CORSMIddleware+BananaCakePop.swift b/Sources/Pioneer/Vapor/Extensions/CORS/CORSMIddleware+BananaCakePop.swift
index 065becb..6e19e5e 100644
--- a/Sources/Pioneer/Vapor/Extensions/CORS/CORSMIddleware+BananaCakePop.swift
+++ b/Sources/Pioneer/Vapor/Extensions/CORS/CORSMIddleware+BananaCakePop.swift
@@ -9,7 +9,7 @@ import struct NIOHTTP1.HTTPHeaders
 import enum NIOHTTP1.HTTPMethod
 import class Vapor.CORSMiddleware
 
-extension CORSMiddleware.Configuration {
+public extension CORSMiddleware.Configuration {
     /// Setup CORS for GraphQL allowing Banana Cake Pop GraphQL IDE (Cloud Version)
     ///
     /// - Parameters:
@@ -17,7 +17,7 @@ extension CORSMiddleware.Configuration {
     ///   - credentials: Allowing credentials through CORS
     ///   - headers: Allowed header names
     /// - Returns: CORS Configuration
-    public static func bananaCakePop(
+    static func bananaCakePop(
         origins urls: [String] = [],
         credentials: Bool = false,
         additionalHeaders headers: [HTTPHeaders.Name] = []
@@ -25,9 +25,9 @@ extension CORSMiddleware.Configuration {
         let allowedOrigin: CORSMiddleware.AllowOriginSetting = .any(["https://eat.bananacakepop.com/"] + urls)
         let allowedMethods: [HTTPMethod] = [.GET, .POST, .OPTIONS]
         let allowedHeaders: [HTTPHeaders.Name] = [
-            .secWebSocketProtocol, .accept, .authorization, .contentType, .origin, .userAgent, .accessControlAllowOrigin, .xRequestedWith
+            .secWebSocketProtocol, .accept, .authorization, .contentType, .origin, .userAgent, .accessControlAllowOrigin, .xRequestedWith,
         ] + headers
-        
+
         return .init(
             allowedOrigin: allowedOrigin,
             allowedMethods: allowedMethods,
diff --git a/Sources/Pioneer/Vapor/Extensions/CORS/CORSMiddleware+ApolloSandbox.swift b/Sources/Pioneer/Vapor/Extensions/CORS/CORSMiddleware+ApolloSandbox.swift
index 17be3a2..a8349b7 100644
--- a/Sources/Pioneer/Vapor/Extensions/CORS/CORSMiddleware+ApolloSandbox.swift
+++ b/Sources/Pioneer/Vapor/Extensions/CORS/CORSMiddleware+ApolloSandbox.swift
@@ -9,7 +9,7 @@ import struct NIOHTTP1.HTTPHeaders
 import enum NIOHTTP1.HTTPMethod
 import class Vapor.CORSMiddleware
 
-extension CORSMiddleware.Configuration {
+public extension CORSMiddleware.Configuration {
     /// Setup CORS for GraphQL allowing Apollo Sandbox
     ///
     /// - Parameters:
@@ -17,7 +17,7 @@ extension CORSMiddleware.Configuration {
     ///   - credentials: Allowing credentials through CORS
     ///   - headers: Allowed header names
     /// - Returns: CORS Configuration
-    public static func apolloSandbox(
+    static func apolloSandbox(
         origins urls: [String] = [],
         credentials: Bool = true,
         additionalHeaders headers: [HTTPHeaders.Name] = []
@@ -25,9 +25,9 @@ extension CORSMiddleware.Configuration {
         let allowedOrigin: CORSMiddleware.AllowOriginSetting = .any(["https://studio.apollographql.com"] + urls)
         let allowedMethods: [HTTPMethod] = [.GET, .POST, .OPTIONS]
         let allowedHeaders: [HTTPHeaders.Name] = [
-            .secWebSocketProtocol, .accept, .authorization, .contentType, .origin, .userAgent, .accessControlAllowOrigin, .xRequestedWith
+            .secWebSocketProtocol, .accept, .authorization, .contentType, .origin, .userAgent, .accessControlAllowOrigin, .xRequestedWith,
         ] + headers
-        
+
         return .init(
             allowedOrigin: allowedOrigin,
             allowedMethods: allowedMethods,
diff --git a/Sources/Pioneer/Vapor/Extensions/EnvironmentVariables/EnvironmentVariables.swift b/Sources/Pioneer/Vapor/Extensions/EnvironmentVariables/EnvironmentVariables.swift
index 145293a..20bbbac 100644
--- a/Sources/Pioneer/Vapor/Extensions/EnvironmentVariables/EnvironmentVariables.swift
+++ b/Sources/Pioneer/Vapor/Extensions/EnvironmentVariables/EnvironmentVariables.swift
@@ -7,7 +7,7 @@
 
 import struct Vapor.Environment
 
-extension Environment {
+public extension Environment {
     /// Setup an environment by specifying the information required
     ///
     /// - Parameters:
@@ -15,14 +15,14 @@ extension Environment {
     ///   - host: Host used, default to "localhost"
     ///   - env: Runtime environment
     /// - Returns: A Environment for Vapor application
-    public static func specified(
+    static func specified(
         port: Int = 4000,
         host: String = "localhost",
         env: String = "development"
     ) throws -> Environment {
         let build = CommandLine.arguments.first ?? ""
         return try .detect(arguments: [
-            build, "serve", "--env", env, "--port", "\(port)", "--hostname", host
+            build, "serve", "--env", env, "--port", "\(port)", "--hostname", host,
         ])
     }
 }
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/GraphQLJSONEncoder+ContentEncoder.swift b/Sources/Pioneer/Vapor/Extensions/Request/GraphQLJSONEncoder+ContentEncoder.swift
index 612ea09..a2e4d33 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/GraphQLJSONEncoder+ContentEncoder.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/GraphQLJSONEncoder+ContentEncoder.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 11:30.
 //
 
-import Vapor
 import class GraphQL.GraphQLJSONEncoder
+import Vapor
 
 extension GraphQLJSONEncoder: ContentEncoder {
-    public func encode<E>(_ encodable: E, to body: inout NIOCore.ByteBuffer, headers: inout NIOHTTP1.HTTPHeaders) throws where E : Encodable {
+    public func encode<E>(_ encodable: E, to body: inout NIOCore.ByteBuffer, headers: inout NIOHTTP1.HTTPHeaders) throws where E: Encodable {
         headers.contentType = .json
         try body.writeBytes(self.encode(encodable))
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift b/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
index 16e89ae..e98db7b 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
@@ -5,22 +5,21 @@
 //  Created by d-exclaimation on 12:30.
 //
 
-import class Vapor.Request
-import struct Vapor.Abort
 import struct GraphQL.GraphQLError
 import enum GraphQL.Map
+import struct Vapor.Abort
+import class Vapor.Request
 
-extension Request {
+public extension Request {
     /// Get the GraphQLRequest from the request
-    public var graphql: GraphQLRequest {
+    var graphql: GraphQLRequest {
         get throws {
-            switch (self.method) {
+            switch self.method {
             case .GET:
                 // Query is most important and should always be there, otherwise reject request
                 guard let query: String = self.query[String.self, at: "query"] else {
                     throw Abort(.badRequest,
-                        reason: "Unable to parse query and identify operation. Specify the 'query' query string parameter with the GraphQL query."
-                    )
+                                reason: "Unable to parse query and identify operation. Specify the 'query' query string parameter with the GraphQL query.")
                 }
                 let variables: [String: Map]? = self.query[String.self, at: "variables"]
                     .flatMap { $0.data(using: .utf8)?.to([String: Map].self) }
@@ -36,12 +35,10 @@ extension Request {
                     return try self.content.decode(GraphQLRequest.self)
                 } catch GraphQLRequest.ParsingIssue.missingQuery {
                     throw Abort(accept.contains(GraphQLRequest.acceptType) ? .badRequest : .ok,
-                        reason: "Missing query parameter"
-                    )
+                                reason: "Missing query parameter")
                 } catch GraphQLRequest.ParsingIssue.invalidForm {
-                    throw Abort(accept.contains(GraphQLRequest.acceptType) ? .badRequest : .ok, 
-                        reason: "Invalid GraphQL request form"
-                    )
+                    throw Abort(accept.contains(GraphQLRequest.acceptType) ? .badRequest : .ok,
+                                reason: "Invalid GraphQL request form")
                 } catch {
                     throw Abort(.badRequest, reason: "Unable to parse JSON")
                 }
@@ -51,4 +48,4 @@ extension Request {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/Request+PathComponent.swift b/Sources/Pioneer/Vapor/Extensions/Request/Request+PathComponent.swift
index c2ee07b..b2a94fe 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/Request+PathComponent.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/Request+PathComponent.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 20:14.
 //
 
-import class Vapor.Request
 import enum Vapor.PathComponent
+import class Vapor.Request
 
-extension Request {
+public extension Request {
     /// Path components from given URI path
-    public var pathComponents: [String] {
+    var pathComponents: [String] {
         guard let path = url.path.split(separator: "?", omittingEmptySubsequences: true).first else {
             return []
         }
@@ -24,9 +24,9 @@ extension Request {
     /// Match the request url and the path components
     /// - Parameter path: The path components to be match against
     /// - Returns: True if url matches the path components
-    public func matching(path: [PathComponent]) -> Bool {
+    func matching(path: [PathComponent]) -> Bool {
         let components = pathComponents
-        
+
         // Empty path, only matches empty url
         guard !path.isEmpty else {
             return components.isEmpty
@@ -35,20 +35,20 @@ extension Request {
         // Zipped the path and url together, fill the missing ones with an empty ""
         let zipped = path
             .enumerated()
-            .map { (i, each) -> (String?, PathComponent) in 
+            .map { i, each -> (String?, PathComponent) in
                 i < components.count ? (components[i], each) : (nil, each)
             }
 
         for (component, pattern) in zipped {
-            switch (pattern) {
-                case .catchall:
-                    return true
-                case .anything, .constant(component):
-                    continue
-                default:
-                    return false
+            switch pattern {
+            case .catchall:
+                return true
+            case .anything, .constant(component):
+                continue
+            default:
+                return false
             }
         }
         return components.count == path.count
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/Request+WebSocket.swift b/Sources/Pioneer/Vapor/Extensions/Request/Request+WebSocket.swift
index c945e17..87f36dd 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/Request+WebSocket.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/Request+WebSocket.swift
@@ -7,12 +7,12 @@
 
 import class Vapor.Request
 
-extension Request {
+public extension Request {
     /// Check if ths request is an upgrade to WebSocket request
-    public var isWebSocketUpgrade: Bool {
+    var isWebSocketUpgrade: Bool {
         guard let connection = headers.first(name: .connection), let upgrade = headers.first(name: .upgrade) else {
             return false
         }
         return connection.lowercased() == "upgrade" && upgrade.lowercased() == "websocket"
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/Request+WebsocketContext.swift b/Sources/Pioneer/Vapor/Extensions/Request/Request+WebsocketContext.swift
index 1381b33..cf636a9 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/Request+WebsocketContext.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/Request+WebsocketContext.swift
@@ -1,5 +1,5 @@
 //  Request+WebsocketContext.swift
-//  
+//
 //
 //  Created by d-exclaimation on 18/06/22.
 //
@@ -17,7 +17,7 @@ public extension Request {
         payload: Payload,
         gql: GraphQLRequest,
         contextBuilder: @Sendable @escaping (Request, Response) async throws -> Context
-    ) async throws -> Context  {
+    ) async throws -> Context {
         let uri = URI(
             scheme: url.scheme,
             host: url.host,
@@ -48,23 +48,23 @@ public extension Payload {
         guard let query = payload["query"] ?? payload["queries"] ?? payload["queryParams"] ?? payload["queryParameters"] else { return "" }
         switch query {
         // Single string query variables in form of "key1=value1&key2=value2"
-        case .string(let str):
+        case let .string(str):
             return str.contains("=") ? str : ""
         // Multiple list of query string in form of ["key=value", ...]
-        case .array(let strings):
+        case let .array(strings):
             return strings
                 .compactMap {
-                    guard case .string(let str) = $0 else {
+                    guard case let .string(str) = $0 else {
                         return nil
                     }
                     return str.contains("=") ? str : nil
                 }
                 .joined(separator: "&")
         // Multiple query strings in form of ["key": "value", ...]
-        case .dictionary(let queries):
+        case let .dictionary(queries):
             return queries
                 .map { key, val in
-                    guard case .string(let value) = val else {
+                    guard case let .string(value) = val else {
                         return "\(key)=\(val.jsonString)"
                     }
                     return "\(key)=\(value)"
@@ -74,20 +74,20 @@ public extension Payload {
             return ""
         }
     }
-    
+
     /// HTTPHeaaders from connection parameter
     var headers: HTTPHeaders {
         guard let payload = self else { return .init() }
-        guard case .dictionary(let headerDict) = payload["header"] ?? payload["headers"] else {
-            return .init(payload.map { (key, val) in
-                guard case .string(let value) = val else {
+        guard case let .dictionary(headerDict) = payload["header"] ?? payload["headers"] else {
+            return .init(payload.map { key, val in
+                guard case let .string(value) = val else {
                     return (key, val.jsonString)
                 }
                 return (key, value)
             })
         }
-        return .init(headerDict.map { (key, val) in
-            guard case .string(let value) = val else {
+        return .init(headerDict.map { key, val in
+            guard case let .string(value) = val else {
                 return (key, val.jsonString)
             }
             return (key, value)
@@ -95,7 +95,6 @@ public extension Payload {
     }
 }
 
-
 extension Optional {
     /// Check if the optional is not empty
     var isSome: Bool {
diff --git a/Sources/Pioneer/Vapor/Extensions/Response/Response+GraphQLError.swift b/Sources/Pioneer/Vapor/Extensions/Response/Response+GraphQLError.swift
index fa296ed..0c2f92e 100644
--- a/Sources/Pioneer/Vapor/Extensions/Response/Response+GraphQLError.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Response/Response+GraphQLError.swift
@@ -1,15 +1,15 @@
 //  Response+GraphQLError.swift
-//  
+//
 //
 //  Created by d-exclaimation on 25/06/22.
 //
 
+import struct GraphQL.GraphQLError
+import struct GraphQL.GraphQLResult
+import struct NIOHTTP1.HTTPHeaders
 import protocol Vapor.AbortError
 import enum Vapor.HTTPResponseStatus
 import class Vapor.Response
-import struct NIOHTTP1.HTTPHeaders
-import struct GraphQL.GraphQLError
-import struct GraphQL.GraphQLResult
 
 extension AbortError {
     func response(using response: Response) throws -> Response {
diff --git a/Sources/Pioneer/Vapor/Extensions/WebSocket/WebSocket+WebSocketable.swift b/Sources/Pioneer/Vapor/Extensions/WebSocket/WebSocket+WebSocketable.swift
index 814a765..15a3cd8 100644
--- a/Sources/Pioneer/Vapor/Extensions/WebSocket/WebSocket+WebSocketable.swift
+++ b/Sources/Pioneer/Vapor/Extensions/WebSocket/WebSocket+WebSocketable.swift
@@ -16,4 +16,4 @@ extension WebSocket: WebSocketable {
     public func terminate(code: WebSocketErrorCode) async throws {
         try await close(code: code)
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift b/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
index 1983722..553b17f 100644
--- a/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
+++ b/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
@@ -5,33 +5,32 @@
 //  Created by d-exclaimation on 11:34 AM.
 //
 
-import Vapor
-import enum GraphQL.OperationType
-import enum GraphQL.Map
 import struct GraphQL.GraphQLError
 import class GraphQL.GraphQLJSONEncoder
+import enum GraphQL.Map
+import enum GraphQL.OperationType
+import Vapor
 
-
-extension Pioneer {
+public extension Pioneer {
     /// Vapor-based HTTP Context builder
-    public typealias VaporHTTPContext = @Sendable (Request, Response) async throws -> Context
+    typealias VaporHTTPContext = @Sendable (Request, Response) async throws -> Context
 
     /// Common Handler for GraphQL through HTTP
     /// - Parameter req: The HTTP request being made
     /// - Returns: A response from the GraphQL operation execution properly formatted
-    public func httpHandler(req: Request, context: @escaping VaporHTTPContext) async throws -> Response {
+    func httpHandler(req: Request, context: @escaping VaporHTTPContext) async throws -> Response {
         try await httpHandler(req: req, using: GraphQLJSONEncoder(), context: context)
     }
-    
+
     /// Common Handler for GraphQL through HTTP
     /// - Parameters:
     ///   - req: The HTTP request being made
     ///   - using: The custom content encoder
     /// - Returns: A response from the GraphQL operation execution properly formatted
-    public func httpHandler(req: Request, using encoder: ContentEncoder, context: @escaping VaporHTTPContext) async throws -> Response {
+    func httpHandler(req: Request, using encoder: ContentEncoder, context: @escaping VaporHTTPContext) async throws -> Response {
         let res = Response()
         do {
-            // Parsing GraphQLRequest and Context 
+            // Parsing GraphQLRequest and Context
             let gql = try req.graphql
             let context = try await context(req, res)
             let httpReq = HTTPGraphQLRequest(request: gql, headers: req.headers, method: req.method)
diff --git a/Sources/Pioneer/Vapor/Http/Pioneer+IDE.swift b/Sources/Pioneer/Vapor/Http/Pioneer+IDE.swift
index b98b1e9..2b3462e 100644
--- a/Sources/Pioneer/Vapor/Http/Pioneer+IDE.swift
+++ b/Sources/Pioneer/Vapor/Http/Pioneer+IDE.swift
@@ -11,17 +11,17 @@ extension Pioneer {
     /// - Parameter req: The HTTP request being made
     /// - Returns: A response with the GraphQL IDE
     public func ideHandler(req: Request) -> Response {
-        switch (playground) {
-            case .playground:
-                return serve(html: playgroundHtml)
-            case .graphiql:
-                return serve(html: graphiqlHtml)
-            case .sandbox:
-                return serve(html: embeddedSandboxHtml)
-            case .redirect(to: let cloud):
-                return req.redirect(to: cloud.url, type: .permanent)
-            case .disable:
-                return Response(status: .notFound)
+        switch playground {
+        case .playground:
+            return serve(html: playgroundHtml)
+        case .graphiql:
+            return serve(html: graphiqlHtml)
+        case .sandbox:
+            return serve(html: embeddedSandboxHtml)
+        case let .redirect(to: cloud):
+            return req.redirect(to: cloud.url, type: .permanent)
+        case .disable:
+            return Response(status: .notFound)
         }
     }
 
@@ -33,6 +33,6 @@ extension Pioneer {
             status: .ok,
             headers: HTTPHeaders([(HTTPHeaders.Name.contentType.description, "text/html")]),
             body: Response.Body(string: html)
-        ) 
+        )
     }
 }
diff --git a/Sources/Pioneer/Vapor/Pioneer+Standalone.swift b/Sources/Pioneer/Vapor/Pioneer+Standalone.swift
index 4a1d7b3..7e8a668 100644
--- a/Sources/Pioneer/Vapor/Pioneer+Standalone.swift
+++ b/Sources/Pioneer/Vapor/Pioneer+Standalone.swift
@@ -5,16 +5,15 @@
 //  Created by d-exclaimation on 00:02.
 //
 
-import struct Vapor.Middlewares
 import class Vapor.Application
 import class Vapor.CORSMiddleware
 import class Vapor.ErrorMiddleware
-import enum Vapor.PathComponent
-import enum Vapor.HTTPMethod
 import enum Vapor.HTTPBodyStreamStrategy
+import enum Vapor.HTTPMethod
+import struct Vapor.Middlewares
+import enum Vapor.PathComponent
 
-extension Pioneer {
-
+public extension Pioneer {
     /// Create an instance of Vapor server to run Pioneer
     /// - Parameters:
     ///   - middleware: The Vapor Middleware to be used
@@ -24,8 +23,8 @@ extension Pioneer {
     ///   - cors: CORS Configuration for the standalone server
     internal func vaporServer(
         middleware: VaporGraphQLMiddleware,
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         cors: CORSMiddleware.Configuration? = nil
     ) throws {
@@ -58,12 +57,12 @@ extension Pioneer {
     ///   - websocketContext: WebSocket context builder
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: PathComponent = "graphql",
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         context: @escaping VaporHTTPContext,
         websocketContext: @escaping VaporWebSocketContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
@@ -71,10 +70,10 @@ extension Pioneer {
     ) throws {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
-                context: context, 
-                websocketContext: websocketContext, 
+                body: body,
+                at: path,
+                context: context,
+                websocketContext: websocketContext,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -94,21 +93,21 @@ extension Pioneer {
     ///   - context: HTTP context builder
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: PathComponent = "graphql",
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         context: @escaping VaporHTTPContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
         cors: CORSMiddleware.Configuration? = nil
     ) throws {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
-                context: context, 
+                body: body,
+                at: path,
+                context: context,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -127,19 +126,19 @@ extension Pioneer {
     ///   - body: The body streaming strategy
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: PathComponent = "graphql",
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
         cors: CORSMiddleware.Configuration? = nil
     ) throws where Context == Void {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
+                body: body,
+                at: path,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -160,12 +159,12 @@ extension Pioneer {
     ///   - websocketContext: WebSocket context builder
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: [PathComponent],
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         context: @escaping VaporHTTPContext,
         websocketContext: @escaping VaporWebSocketContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
@@ -173,10 +172,10 @@ extension Pioneer {
     ) throws {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
-                context: context, 
-                websocketContext: websocketContext, 
+                body: body,
+                at: path,
+                context: context,
+                websocketContext: websocketContext,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -196,21 +195,21 @@ extension Pioneer {
     ///   - context: HTTP context builder
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: [PathComponent],
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         context: @escaping VaporHTTPContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
         cors: CORSMiddleware.Configuration? = nil
     ) throws {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
-                context: context, 
+                body: body,
+                at: path,
+                context: context,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -229,19 +228,19 @@ extension Pioneer {
     ///   - body: The body streaming strategy
     ///   - websocketGuard: WebSocket connection guard
     ///   - cors: CORS Configuration for the standalone server
-    public func standaloneServer(
-        port: Int = 4000, 
-        host: String = "127.0.0.1", 
+    func standaloneServer(
+        port: Int = 4000,
+        host: String = "127.0.0.1",
         env: String = "development",
         at path: [PathComponent],
-        body: HTTPBodyStreamStrategy = .collect, 
+        body: HTTPBodyStreamStrategy = .collect,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in },
         cors: CORSMiddleware.Configuration? = nil
     ) throws where Context == Void {
         try vaporServer(
             middleware: vaporMiddleware(
-                body: body, 
-                at: path, 
+                body: body,
+                at: path,
                 websocketGuard: websocketGuard
             ),
             port: port,
@@ -250,4 +249,4 @@ extension Pioneer {
             cors: cors
         )
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Pioneer+Vapor+Void.swift b/Sources/Pioneer/Vapor/Pioneer+Vapor+Void.swift
index 3c57594..f00d841 100644
--- a/Sources/Pioneer/Vapor/Pioneer+Vapor+Void.swift
+++ b/Sources/Pioneer/Vapor/Pioneer+Vapor+Void.swift
@@ -5,28 +5,28 @@
 //  Created by d-exclaimation on 16:00.
 //
 
-import enum Vapor.PathComponent
-import enum Vapor.HTTPMethod
 import enum Vapor.HTTPBodyStreamStrategy
+import enum Vapor.HTTPMethod
+import enum Vapor.PathComponent
 
-extension Pioneer {
+public extension Pioneer {
     /// Pioneer GraphQL handlers for Vapor
     /// - Parameters:
     ///   - body: The body streaming strategy
     ///   - path: The path component where GraphQL should be operated
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: PathComponent = "graphql",
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in }
     ) -> VaporGraphQLMiddleware where Context == Void {
         VaporGraphQLMiddleware(
             server: self,
             path: [path],
-            body: body, 
+            body: body,
             context: { _, _ in },
-            websocketContext: { _, _, _ in }, 
+            websocketContext: { _, _, _ in },
             websocketGuard: websocketGuard
         )
     }
@@ -37,8 +37,8 @@ extension Pioneer {
     ///   - path: The path components where GraphQL should be operated
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: [PathComponent],
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in }
     ) -> VaporGraphQLMiddleware where Context == Void {
@@ -51,4 +51,4 @@ extension Pioneer {
             websocketGuard: websocketGuard
         )
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/Pioneer+Vapor.swift b/Sources/Pioneer/Vapor/Pioneer+Vapor.swift
index 579a35c..0e48205 100644
--- a/Sources/Pioneer/Vapor/Pioneer+Vapor.swift
+++ b/Sources/Pioneer/Vapor/Pioneer+Vapor.swift
@@ -6,17 +6,16 @@
 //
 
 import protocol Vapor.AsyncMiddleware
+import protocol Vapor.AsyncResponder
+import enum Vapor.HTTPBodyStreamStrategy
+import enum Vapor.HTTPMethod
+import enum Vapor.PathComponent
 import class Vapor.Request
 import class Vapor.Response
-import enum Vapor.PathComponent
-import enum Vapor.HTTPMethod
-import enum Vapor.HTTPBodyStreamStrategy
-import protocol Vapor.AsyncResponder
-
-extension Pioneer {
 
+public extension Pioneer {
     /// Pioneer Integration for Vapor as a Middleware
-    public struct VaporGraphQLMiddleware: AsyncMiddleware {
+    struct VaporGraphQLMiddleware: AsyncMiddleware {
         /// Service to serve by the middleware
         enum Serve {
             /// GraphQL over HTTP operation should be served
@@ -27,7 +26,7 @@ extension Pioneer {
 
             /// GraphQL IDE should be served
             case playground
-            
+
             /// No service, skip this middleware
             case ignore
         }
@@ -36,7 +35,7 @@ extension Pioneer {
         private let server: Pioneer
 
         /// The path to be served
-        private let path: [PathComponent] 
+        private let path: [PathComponent]
 
         /// The body stream strategy used
         private let body: HTTPBodyStreamStrategy
@@ -51,7 +50,7 @@ extension Pioneer {
         private let websocketGuard: VaporWebSocketGuard
 
         internal init(
-            server: Pioneer, 
+            server: Pioneer,
             path: [PathComponent],
             body: HTTPBodyStreamStrategy,
             context: @escaping VaporHTTPContext,
@@ -61,14 +60,14 @@ extension Pioneer {
             self.path = path
             self.body = body
             self.context = context
-            self.websocketContext = { 
+            self.websocketContext = {
                 try await $0.defaultWebsocketContextBuilder(payload: $1, gql: $2, contextBuilder: context)
             }
             self.websocketGuard = websocketGuard
         }
 
         internal init(
-            server: Pioneer, 
+            server: Pioneer,
             path: [PathComponent],
             body: HTTPBodyStreamStrategy,
             context: @escaping VaporHTTPContext,
@@ -113,13 +112,13 @@ extension Pioneer {
         /// - Parameter request: The incoming request
         /// - Returns: The request after the body is collected if necessary
         private func collect(_ request: Request) async throws -> Request {
-            if case .collect(let max) = body, request.body.data == nil {
+            if case let .collect(max) = body, request.body.data == nil {
                 let _ = try await request.body
                     .collect(max: max?.value ?? request.application.routes.defaultMaxBodySize.value)
                     .get()
                 return request
             }
-            return request 
+            return request
         }
 
         public func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
@@ -128,14 +127,14 @@ extension Pioneer {
             }
 
             switch try await serving(to: request) {
-                case .operation:
-                    return try await server.httpHandler(req: collect(request), context: context)
-                case .upgrade:
-                    return try await server.webSocketHandler(req: collect(request), context: websocketContext, guard: websocketGuard)
-                case .playground:
-                    return server.ideHandler(req: request)
-                case .ignore:
-                    return try await next.respond(to: request)
+            case .operation:
+                return try await server.httpHandler(req: collect(request), context: context)
+            case .upgrade:
+                return try await server.webSocketHandler(req: collect(request), context: websocketContext, guard: websocketGuard)
+            case .playground:
+                return server.ideHandler(req: request)
+            case .ignore:
+                return try await next.respond(to: request)
             }
         }
     }
@@ -147,17 +146,17 @@ extension Pioneer {
     ///   - context: HTTP context builder
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: PathComponent = "graphql",
         context: @escaping VaporHTTPContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in }
     ) -> VaporGraphQLMiddleware {
         VaporGraphQLMiddleware(
-            server: self, 
-            path: [path], 
-            body: body, 
-            context: context, 
+            server: self,
+            path: [path],
+            body: body,
+            context: context,
             websocketGuard: websocketGuard
         )
     }
@@ -170,8 +169,8 @@ extension Pioneer {
     ///   - websocketContext: WebSocket context builder
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: PathComponent = "graphql",
         context: @escaping VaporHTTPContext,
         websocketContext: @escaping VaporWebSocketContext,
@@ -194,8 +193,8 @@ extension Pioneer {
     ///   - context: HTTP context builder
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: [PathComponent],
         context: @escaping VaporHTTPContext,
         websocketGuard: @escaping VaporWebSocketGuard = { _, _ in }
@@ -217,8 +216,8 @@ extension Pioneer {
     ///   - websocketContext: WebSocket context builder
     ///   - websocketGuard: WebSocket connection guard
     /// - Returns: Middleware for handling GraphQL operation
-    public func vaporMiddleware(
-        body: HTTPBodyStreamStrategy = .collect, 
+    func vaporMiddleware(
+        body: HTTPBodyStreamStrategy = .collect,
         at path: [PathComponent],
         context: @escaping VaporHTTPContext,
         websocketContext: @escaping VaporWebSocketContext,
@@ -233,4 +232,4 @@ extension Pioneer {
             websocketGuard: websocketGuard
         )
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/Vapor/WebSocket/Pioneer+WebSocket.swift b/Sources/Pioneer/Vapor/WebSocket/Pioneer+WebSocket.swift
index 33c3bf1..6765bb1 100644
--- a/Sources/Pioneer/Vapor/WebSocket/Pioneer+WebSocket.swift
+++ b/Sources/Pioneer/Vapor/WebSocket/Pioneer+WebSocket.swift
@@ -5,20 +5,20 @@
 //  Created by d-exclaimation on 11:36 AM.
 //
 
-import Vapor
 import struct GraphQL.GraphQLError
+import Vapor
 
-extension Pioneer {
+public extension Pioneer {
     /// Vapor-based WebSocket Context builder
-    public typealias VaporWebSocketContext = @Sendable (Request, Payload, GraphQLRequest) async throws -> Context
+    typealias VaporWebSocketContext = @Sendable (Request, Payload, GraphQLRequest) async throws -> Context
 
     /// Vapor-based WebSocket Guard
-    public typealias VaporWebSocketGuard = @Sendable (Request, Payload) async throws -> Void
+    typealias VaporWebSocketGuard = @Sendable (Request, Payload) async throws -> Void
 
     /// Upgrade Handler for all GraphQL through Websocket
     /// - Parameter req: Request made to upgrade to Websocket
     /// - Returns: Response to upgrade connection to Websocket
-    public func webSocketHandler(req: Request, context: @escaping VaporWebSocketContext, guard: @escaping VaporWebSocketGuard) async throws -> Response {
+    func webSocketHandler(req: Request, context: @escaping VaporWebSocketContext, guard: @escaping VaporWebSocketGuard) async throws -> Response {
         /// Explicitly handle Websocket upgrade with sub-protocol
         let protocolHeader: [String] = req.headers[.secWebSocketProtocol]
         guard let _ = protocolHeader.first(where: websocketProtocol.isValid) else {
@@ -26,20 +26,20 @@ extension Pioneer {
                 message: "Unrecognized websocket protocol. Specify the 'sec-websocket-protocol' header with '\(websocketProtocol.name)'"
             )
             .response(with: .badRequest)
-        } 
+        }
 
-        return req.webSocket(shouldUpgrade: shouldUpgrade(req:), onUpgrade: { 
-            onUpgrade(req: $0, ws: $1, context: context, guard: `guard`) 
+        return req.webSocket(shouldUpgrade: shouldUpgrade(req:), onUpgrade: {
+            onUpgrade(req: $0, ws: $1, context: context, guard: `guard`)
         })
     }
-    
+
     /// Should upgrade callback
-    func shouldUpgrade(req: Request) -> EventLoopFuture<HTTPHeaders?> {
+    internal func shouldUpgrade(req: Request) -> EventLoopFuture<HTTPHeaders?> {
         req.eventLoop.next().makeSucceededFuture(.init([("Sec-WebSocket-Protocol", websocketProtocol.name)]))
     }
 
     /// On upgrade callback
-    func onUpgrade(req: Request, ws: WebSocket, context: @escaping VaporWebSocketContext, guard: @escaping VaporWebSocketGuard) -> Void {
+    internal func onUpgrade(req: Request, ws: WebSocket, context: @escaping VaporWebSocketContext, guard: @escaping VaporWebSocketGuard) {
         let cid = UUID()
 
         let keepAlive = keepAlive(using: ws)
@@ -48,10 +48,10 @@ extension Pioneer {
 
         // Task for consuming WebSocket messages to avoid cyclic references and provide cleaner code
         let receiving = Task {
-            let stream = AsyncStream(String.self) { con in 
+            let stream = AsyncStream(String.self) { con in
                 ws.onText { con.yield($1) }
 
-                con.onTermination = { @Sendable _ in 
+                con.onTermination = { @Sendable _ in
                     guard ws.isClosed else { return }
                     _ = ws.close()
                 }
@@ -59,10 +59,10 @@ extension Pioneer {
 
             for await message in stream {
                 await receiveMessage(
-                    cid: cid, io: ws, 
-                    keepAlive: keepAlive, 
+                    cid: cid, io: ws,
+                    keepAlive: keepAlive,
                     timeout: timeout,
-                    ev: req.eventLoop, 
+                    ev: req.eventLoop,
                     txt: message,
                     context: {
                         try await context(req, $0, $1)
diff --git a/Sources/Pioneer/WebSocket/Common/Payload.swift b/Sources/Pioneer/WebSocket/Common/Payload.swift
index 833024d..6558561 100644
--- a/Sources/Pioneer/WebSocket/Common/Payload.swift
+++ b/Sources/Pioneer/WebSocket/Common/Payload.swift
@@ -8,4 +8,4 @@
 import enum GraphQL.Map
 
 /// WebSocket Payload
-public typealias Payload = [String: Map]?
\ No newline at end of file
+public typealias Payload = [String: Map]?
diff --git a/Sources/Pioneer/WebSocket/Common/Pioneer+WebSocketable.swift b/Sources/Pioneer/WebSocket/Common/Pioneer+WebSocketable.swift
index f8cfd37..03a1336 100644
--- a/Sources/Pioneer/WebSocket/Common/Pioneer+WebSocketable.swift
+++ b/Sources/Pioneer/WebSocket/Common/Pioneer+WebSocketable.swift
@@ -24,4 +24,4 @@ public extension Pioneer {
             keepAlive?.cancel()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/WebSocket/Common/WebSocketClient.swift b/Sources/Pioneer/WebSocket/Common/WebSocketClient.swift
index 09b825b..feab0f7 100644
--- a/Sources/Pioneer/WebSocket/Common/WebSocketClient.swift
+++ b/Sources/Pioneer/WebSocket/Common/WebSocketClient.swift
@@ -6,19 +6,19 @@
 //
 
 import Foundation
-import enum NIOWebSocket.WebSocketErrorCode
 import class NIO.EventLoopFuture
 import protocol NIO.EventLoopGroup
+import enum NIOWebSocket.WebSocketErrorCode
 
-extension Pioneer {
+public extension Pioneer {
     /// WebSocket initialisation guard
-    public typealias WebSocketGuard = @Sendable (Payload) async throws -> Void
+    typealias WebSocketGuard = @Sendable (Payload) async throws -> Void
 
     /// WebSocket Context Builder
-    public typealias WebSocketContext = @Sendable (Payload, GraphQLRequest) async throws -> Context
+    typealias WebSocketContext = @Sendable (Payload, GraphQLRequest) async throws -> Context
 
     /// Full GraphQL over WebSocket Client
-    public struct WebSocketClient {
+    struct WebSocketClient {
         /// The unique key for this client
         var id: UUID
 
@@ -68,4 +68,4 @@ extension Pioneer {
             try await contextBuilder(payload, gql)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/WebSocket/Common/WebSocketable.swift b/Sources/Pioneer/WebSocket/Common/WebSocketable.swift
index c3ec7d6..a9e78ca 100644
--- a/Sources/Pioneer/WebSocket/Common/WebSocketable.swift
+++ b/Sources/Pioneer/WebSocket/Common/WebSocketable.swift
@@ -7,7 +7,7 @@
 
 import enum NIOWebSocket.WebSocketErrorCode
 
-/// Any WebSocket output that can send messages and be terminated 
+/// Any WebSocket output that can send messages and be terminated
 public protocol WebSocketable {
     /// Send a messsage to this websocket consumer
     /// - Parameter msg: The message to be sent
@@ -15,5 +15,5 @@ public protocol WebSocketable {
 
     /// Close the connection
     /// - Parameter code: Error code to close the connection
-    func terminate(code: WebSocketErrorCode) async throws 
-}
\ No newline at end of file
+    func terminate(code: WebSocketErrorCode) async throws
+}
diff --git a/Sources/Pioneer/WebSocket/Probe/Drone/Drone.swift b/Sources/Pioneer/WebSocket/Probe/Drone/Drone.swift
index 6a4944d..b0732e8 100644
--- a/Sources/Pioneer/WebSocket/Probe/Drone/Drone.swift
+++ b/Sources/Pioneer/WebSocket/Probe/Drone/Drone.swift
@@ -5,8 +5,8 @@
 //  Created by d-exclaimation on 4:55 PM.
 //
 
-import GraphQL
 import class Graphiti.Schema
+import GraphQL
 import protocol NIO.EventLoopGroup
 
 extension Pioneer {
@@ -18,9 +18,9 @@ extension Pioneer {
         private let proto: SubProtocol.Type
 
         init(
-            _ client: WebSocketClient, 
-            schema: GraphQLSchema, 
-            resolver: Resolver, 
+            _ client: WebSocketClient,
+            schema: GraphQLSchema,
+            resolver: Resolver,
             proto: SubProtocol.Type
         ) {
             self.schema = schema
@@ -30,9 +30,9 @@ extension Pioneer {
         }
 
         init(
-            _ client: WebSocketClient, 
-            schema: Schema<Resolver, Context>, 
-            resolver: Resolver, 
+            _ client: WebSocketClient,
+            schema: Schema<Resolver, Context>,
+            resolver: Resolver,
             proto: SubProtocol.Type
         ) {
             self.schema = schema.schema
@@ -42,15 +42,16 @@ extension Pioneer {
         }
 
         // MARK: - Private mutable states
+
         private var tasks: [String: Task<Void, Error>] = [:]
-        
+
         // MARK: - Event callbacks
-        
+
         /// Start subscriptions, setup pipe pattern, and callbacks
         func start(for oid: String, given gql: GraphQLRequest) async {
             let nextTypename = proto.next
             let subscriptionResult = await subscription(gql: gql)
-            
+
             // Guard for getting the required subscriptions stream, if not send `next` with errors, and end subscription
             guard let subscription = subscriptionResult.stream else {
                 let res = GraphQL.GraphQLResult(errors: subscriptionResult.errors)
@@ -58,18 +59,17 @@ extension Pioneer {
                 client.out(GraphQLMessage(id: oid, type: proto.complete).jsonString)
                 return
             }
-            
+
             // Guard for getting the async stream, if not sent `next` saying failure in convertion, and end subscription
             guard let asyncStream = subscription.asyncStream() else {
                 let res = GraphQL.GraphQLResult(errors: [
-                    .init(message: "Internal server error, failed to fetch AsyncThrowingStream")
+                    .init(message: "Internal server error, failed to fetch AsyncThrowingStream"),
                 ])
                 client.out(GraphQLMessage.from(type: proto.next, id: oid, res).jsonString)
                 client.out(GraphQLMessage(id: oid, type: proto.complete).jsonString)
                 return
             }
 
-
             // Transform async stream into messages and pipe back all messages into the Actor itself
             let task = asyncStream.pipe(
                 to: self,
@@ -86,7 +86,7 @@ extension Pioneer {
             )
             tasks.update(oid, with: task)
         }
-        
+
         /// Stop subscription, shutdown task and remove it so preventing overflow of any messages
         func stop(for oid: String) {
             guard let task = tasks[oid] else { return }
@@ -94,7 +94,7 @@ extension Pioneer {
             tasks.delete(oid)
             task.cancel()
         }
-        
+
         /// Send an ending message
         /// but prevent completion message if task doesn't exist
         /// e.g: - Shutdown-ed operation
@@ -104,7 +104,7 @@ extension Pioneer {
             let message = GraphQLMessage(id: oid, type: proto.complete)
             client.out(message.jsonString)
         }
-        
+
         /// Push message to websocket connection
         /// but prevent completion message if task doesn't exist
         /// e.g: - Shutdown-ed operation
@@ -112,13 +112,13 @@ extension Pioneer {
             guard tasks.has(oid) else { return }
             client.out(msg.jsonString)
         }
-        
+
         /// Kill actor by cancelling and deallocating all stored task
         func acid() {
             tasks.values.forEach { $0.cancel() }
             tasks.removeAll()
         }
-        
+
         // MARK: - Utility methods
 
         /// Build context and execute subscription from GraphQL Resolver and Schema, await the future value and catch error into a SubscriptionResult
@@ -137,10 +137,10 @@ extension Pioneer {
         /// Execute long lived GraphQL Operation as a subscription
         private func subscribeOperation(for gql: GraphQLRequest, with ctx: Context, using eventLoop: EventLoopGroup) async throws -> SubscriptionResult {
             try await subscribeGraphQL(
-                schema: schema, 
+                schema: schema,
                 request: gql.query,
-                resolver: resolver, 
-                context: ctx, 
+                resolver: resolver,
+                context: ctx,
                 eventLoopGroup: eventLoop,
                 variables: gql.variables,
                 operationName: gql.operationName
diff --git a/Sources/Pioneer/WebSocket/Probe/Probe.swift b/Sources/Pioneer/WebSocket/Probe/Probe.swift
index fb3fa9f..6362e52 100644
--- a/Sources/Pioneer/WebSocket/Probe/Probe.swift
+++ b/Sources/Pioneer/WebSocket/Probe/Probe.swift
@@ -5,9 +5,9 @@
 //  Created by d-exclaimation on 11:32 PM.
 //
 
-import GraphQL
-import class Graphiti.Schema
 import struct Foundation.UUID
+import class Graphiti.Schema
+import GraphQL
 import protocol NIO.EventLoopGroup
 
 extension Pioneer {
@@ -24,7 +24,7 @@ extension Pioneer {
             self.resolver = resolver
             self.proto = proto
         }
-        
+
         init(
             schema: Schema<Resolver, Context>, resolver: Resolver, proto: SubProtocol.Type
         ) {
@@ -34,58 +34,57 @@ extension Pioneer {
         }
 
         // MARK: - Private mutable states
+
         private var clients: [UUID: WebSocketClient] = [:]
         private var drones: [UUID: Drone] = [:]
-        
-        
+
         // MARK: - Event callbacks
-        
+
         /// Allocate space and save any verified process
         func connect(with client: WebSocketClient) async {
             clients.update(client.id, with: client)
         }
-        
+
         /// Deallocate the space from a closing process
         func disconnect(for cid: UUID) async {
             await drones[cid]?.acid()
             clients.delete(cid)
             drones.delete(cid)
         }
-        
+
         /// Long running operation require its own actor, thus initialing one if there were none prior
         func start(for cid: UUID, with oid: String, given gql: GraphQLRequest) async {
-            guard let client = clients[cid] else { 
+            guard let client = clients[cid] else {
                 return
             }
 
             let drone = drones.getOrElse(cid) {
                 .init(client,
-                    schema: schema,
-                    resolver: resolver,
-                    proto: proto
-                )
+                      schema: schema,
+                      resolver: resolver,
+                      proto: proto)
             }
             drones.update(cid, with: drone)
             await drone.start(for: oid, given: gql)
         }
-        
+
         /// Short lived operation is processed immediately and pipe back later
         func once(for cid: UUID, with oid: String, given gql: GraphQLRequest) async {
-            guard let client = clients[cid] else { 
+            guard let client = clients[cid] else {
                 return
             }
 
             let future = execute(gql, client: client)
-            
+
             pipeToSelf(future: future) { sink, res in
                 switch res {
-                case .success(let value):
+                case let .success(value):
                     await sink.outgoing(
                         with: oid,
                         to: client,
                         given: .from(type: self.proto.next, id: oid, value)
                     )
-                case .failure(let error):
+                case let .failure(error):
                     let result: GraphQLResult = .init(data: nil, errors: [error.graphql])
                     await sink.outgoing(
                         with: oid,
@@ -100,16 +99,16 @@ extension Pioneer {
         func stop(for cid: UUID, with oid: String) async {
             await drones[cid]?.stop(for: oid)
         }
-        
+
         /// Message for pipe to self result after processing short lived operation
         func outgoing(with oid: String, to client: WebSocketClient, given msg: GraphQLMessage) async {
             client.out(msg.jsonString)
             client.out(GraphQLMessage(id: oid, type: proto.complete).jsonString)
         }
-        
+
         // MARK: - Utility methods
-    
-        /// Build context and execute short-lived GraphQL Operation inside an event loop 
+
+        /// Build context and execute short-lived GraphQL Operation inside an event loop
         private func execute(_ gql: GraphQLRequest, client: WebSocketClient) -> Task<GraphQLResult, Error> {
             Task { [unowned self] in
                 let ctx = try await client.context(gql)
@@ -127,7 +126,7 @@ extension Pioneer {
                 eventLoopGroup: eventLoop,
                 variables: gql.variables,
                 operationName: gql.operationName
-            ) 
+            )
         }
     }
 }
diff --git a/Sources/Pioneer/WebSocket/Protocol/GraphQLWs.swift b/Sources/Pioneer/WebSocket/Protocol/GraphQLWs.swift
index 7b99b24..bc44f36 100644
--- a/Sources/Pioneer/WebSocket/Protocol/GraphQLWs.swift
+++ b/Sources/Pioneer/WebSocket/Protocol/GraphQLWs.swift
@@ -10,7 +10,7 @@ import struct Foundation.Data
 /// GraphQL Over Websocket Protocol namespace for `graphql-ws/graphql-transport-ws`
 enum GraphQLWs: SubProtocol {
     static let name: String = "graphql-transport-ws"
-    
+
     private static let Subscribe = "subscribe"
     private static let Next = "next"
     private static let Error = "error"
@@ -27,11 +27,11 @@ enum GraphQLWs: SubProtocol {
         }
         switch (msg.type, msg.payload, msg.id) {
         /// Start an operation whether it is `query`, `mutation`, and `subscriptions`
-        case (Subscribe, .some(let payload), .some(let oid)):
+        case (Subscribe, let .some(payload), let .some(oid)):
             return parseOperation(oid: oid, payload: payload)
 
         // Stop an operation using the OID
-        case (Complete, .none, .some(let oid)):
+        case (Complete, .none, let .some(oid)):
             return .stop(oid: oid)
 
         // Initialize handshake and confirm connection
diff --git a/Sources/Pioneer/WebSocket/Protocol/SubProtocol.swift b/Sources/Pioneer/WebSocket/Protocol/SubProtocol.swift
index e08557c..7baa1f3 100644
--- a/Sources/Pioneer/WebSocket/Protocol/SubProtocol.swift
+++ b/Sources/Pioneer/WebSocket/Protocol/SubProtocol.swift
@@ -6,8 +6,8 @@
 //
 
 import struct Foundation.Data
-import enum NIOWebSocket.WebSocketErrorCode
 import enum GraphQL.Map
+import enum NIOWebSocket.WebSocketErrorCode
 
 /// GraphQL Over Websocket sub-protocol
 protocol SubProtocol {
@@ -60,7 +60,7 @@ extension WebSocketErrorCode {
     static var graphqlNotAuthorized: WebSocketErrorCode {
         .init(codeNumber: 4401)
     }
-    
+
     static var graphqlInitTimeout: WebSocketErrorCode {
         .init(codeNumber: 4408)
     }
diff --git a/Sources/Pioneer/WebSocket/Protocol/SubscriptionsTransportWs.swift b/Sources/Pioneer/WebSocket/Protocol/SubscriptionsTransportWs.swift
index 5c7a949..b7d74d3 100644
--- a/Sources/Pioneer/WebSocket/Protocol/SubscriptionsTransportWs.swift
+++ b/Sources/Pioneer/WebSocket/Protocol/SubscriptionsTransportWs.swift
@@ -28,11 +28,11 @@ enum SubscriptionTransportWs: SubProtocol {
         }
         switch (msg.type, msg.payload, msg.id) {
         /// Start an operation whether it is `query`, `mutation`, and `subscriptions`
-        case (GQL_START, .some(let payload), .some(let oid)):
+        case (GQL_START, let .some(payload), let .some(oid)):
             return parseOperation(oid: oid, payload: payload)
 
         // Stop an operation using the OID
-        case (GQL_STOP, .none, .some(let oid)):
+        case (GQL_STOP, .none, let .some(oid)):
             return .stop(oid: oid)
 
         // Initialize handshake and confirm connection
@@ -53,13 +53,13 @@ enum SubscriptionTransportWs: SubProtocol {
         io.out(ack.jsonString)
         io.out(ka.jsonString)
     }
-    
+
     static var next: String { GQL_DATA }
 
     static var complete: String { GQL_COMPLETE }
 
     static var error: String { GQL_ERROR }
-    
+
     static var pong: String { GQL_CONNECTION_KEEP_ALIVE }
 
     static var keepAliveMessage: String {
diff --git a/Tests/PioneerTests/ActorTests/DroneTests.swift b/Tests/PioneerTests/ActorTests/DroneTests.swift
index a88ee54..193c903 100644
--- a/Tests/PioneerTests/ActorTests/DroneTests.swift
+++ b/Tests/PioneerTests/ActorTests/DroneTests.swift
@@ -7,12 +7,12 @@
 //
 
 import Foundation
-import XCTest
-import NIOWebSocket
-import Vapor
-import GraphQL
 import Graphiti
+import GraphQL
+import NIOWebSocket
 @testable import Pioneer
+import Vapor
+import XCTest
 
 final class DroneTests: XCTestCase {
     private let app = Application(.testing)
@@ -20,12 +20,12 @@ final class DroneTests: XCTestCase {
     deinit {
         app.shutdown()
     }
-    
+
     /// Simple Test Resolver
     class Resolver {
         /// Unused Query resolver, only here to satisfy Schema
         func hello(_: Void, _: NoArguments) -> String { "Hello World!" }
-        
+
         /// Simple 1 messaage subscriptions
         /// Should:
         ///     - Send Hello and finish the stream
@@ -61,7 +61,7 @@ final class DroneTests: XCTestCase {
             )
         }
     }
-    
+
     /// Setup a GraphQLSchema, Pioneer drone, and a TestConsumer
     /// - Returns: The configured consumer and drone itself
     func setup() throws -> (TestConsumer, Pioneer<Resolver, Void>.Drone) {
@@ -74,13 +74,13 @@ final class DroneTests: XCTestCase {
                 SubscriptionField("delayed", as: String.self, atSub: Resolver.delayed)
             }
         }.schema
-        let req = Request.init(application: app, on: app.eventLoopGroup.next())
+        let req = Request(application: app, on: app.eventLoopGroup.next())
         let consumer = TestConsumer()
         let process = Pioneer<Resolver, Void>.WebSocketClient(
-            id: UUID(), 
-            io: consumer, 
+            id: UUID(),
+            io: consumer,
             payload: nil,
-            ev: req.eventLoop, 
+            ev: req.eventLoop,
             context: { _, _ in }
         )
         let drone: Pioneer<Resolver, Void>.Drone = .init(
diff --git a/Tests/PioneerTests/ActorTests/ProbeTests.swift b/Tests/PioneerTests/ActorTests/ProbeTests.swift
index b68e121..9bd6837 100644
--- a/Tests/PioneerTests/ActorTests/ProbeTests.swift
+++ b/Tests/PioneerTests/ActorTests/ProbeTests.swift
@@ -7,11 +7,11 @@
 //
 
 import Foundation
-import XCTest
-import Vapor
-import GraphQL
 import Graphiti
+import GraphQL
 @testable import Pioneer
+import Vapor
+import XCTest
 
 final class ProbeTests: XCTestCase {
     private let app = Application(.testing)
@@ -47,17 +47,17 @@ final class ProbeTests: XCTestCase {
     }
 
     /// Setup a Process using a custom test consumer
-    func consumer() -> (Pioneer<Resolver, Void>.WebSocketClient, TestConsumer)  {
+    func consumer() -> (Pioneer<Resolver, Void>.WebSocketClient, TestConsumer) {
         let req = Request(application: app, on: app.eventLoopGroup.next())
         let consumer = TestConsumer()
         return (
             .init(
-                id: UUID(), 
-                io: consumer, 
-                payload: [:], 
+                id: UUID(),
+                io: consumer,
+                payload: [:],
                 ev: req.eventLoop,
                 context: { _, _ in }
-            ), 
+            ),
             consumer
         )
     }
@@ -74,7 +74,7 @@ final class ProbeTests: XCTestCase {
         await probe.outgoing(with: "1", to: process, given: message)
 
         try? await Task.sleep(nanoseconds: UInt64?.milliseconds(1))
-        
+
         let results = await con.waitAll()
         guard let _ = results.first(where: { $0.contains("\"complete\"") && $0.contains("\"1\"") }) else {
             return XCTFail("No completion")
@@ -145,7 +145,7 @@ final class ProbeTests: XCTestCase {
         guard let message = res.data(using: .utf8)?.to(GraphQLMessage.self) else {
             return XCTFail("Unparseable data")
         }
-        guard let payload = message.payload, case .array(let errors) = payload["errors"] else {
+        guard let payload = message.payload, case let .array(errors) = payload["errors"] else {
             return XCTFail("No payload")
         }
         XCTAssert(!errors.isEmpty)
diff --git a/Tests/PioneerTests/DataStructureTests/AsyncPubSubTests.swift b/Tests/PioneerTests/DataStructureTests/AsyncPubSubTests.swift
index 1410455..bf82c5a 100644
--- a/Tests/PioneerTests/DataStructureTests/AsyncPubSubTests.swift
+++ b/Tests/PioneerTests/DataStructureTests/AsyncPubSubTests.swift
@@ -7,8 +7,8 @@
 
 import Foundation
 import GraphQL
-import XCTest
 @testable import Pioneer
+import XCTest
 
 final class AsyncPubSubTests: XCTestCase {
     /// AsyncPubSub getting `AsyncStream` and publishing data
@@ -20,7 +20,7 @@ final class AsyncPubSubTests: XCTestCase {
         let trigger = "1"
         let exp0 = XCTestExpectation()
         let exp1 = XCTestExpectation()
-        
+
         let task = Task {
             let stream = pubsub.asyncStream(Int.self, for: trigger)
             for await each in stream {
@@ -30,7 +30,7 @@ final class AsyncPubSubTests: XCTestCase {
                 return
             }
         }
-        
+
         let task1 = Task {
             let stream = pubsub.asyncStream(Int.self, for: trigger)
             for await each in stream {
@@ -40,18 +40,18 @@ final class AsyncPubSubTests: XCTestCase {
                 return
             }
         }
-        
+
         try? await Task.sleep(nanoseconds: UInt64?.milliseconds(1))
-        
+
         await pubsub.publish(for: trigger, payload: "invalid")
         await pubsub.publish(for: trigger, payload: 0)
-        
+
         wait(for: [exp0, exp1], timeout: 2)
-        
+
         task.cancel()
         task1.cancel()
     }
-    
+
     /// AsyncPubSub closing all consumer for a specific trigger
     /// - Should close all consumer with the same trigger
     /// - Should never receive anything from any consumer
@@ -60,7 +60,7 @@ final class AsyncPubSubTests: XCTestCase {
         let trigger = "1"
         let exp0 = XCTestExpectation()
         let exp1 = XCTestExpectation()
-        
+
         let task = Task {
             let stream = pubsub.asyncStream(Bool.self, for: trigger)
             for await _ in stream {
@@ -68,7 +68,7 @@ final class AsyncPubSubTests: XCTestCase {
             }
             exp0.fulfill()
         }
-        
+
         let task1 = Task {
             let stream = pubsub.asyncStream(Bool.self, for: trigger)
             for await _ in stream {
@@ -76,19 +76,19 @@ final class AsyncPubSubTests: XCTestCase {
             }
             exp1.fulfill()
         }
-        
+
         try? await Task.sleep(nanoseconds: 500_000)
-        
+
         await pubsub.close(for: trigger)
-        
+
         wait(for: [exp0, exp1], timeout: 2)
-        
+
         task.cancel()
         task1.cancel()
     }
 
     func testAsyncStream() async throws {
-        let stream1 = EventStream<Int>.async { con in 
+        let stream1 = EventStream<Int>.async { con in
             con.yield(1)
             con.finish()
         }
@@ -97,7 +97,7 @@ final class AsyncPubSubTests: XCTestCase {
             XCTAssertEqual(each, 1)
         }
 
-        let stream2 = AsyncEventStream<Int, AsyncThrowingStream<Int, Error>> { con in 
+        let stream2 = AsyncEventStream<Int, AsyncThrowingStream<Int, Error>> { con in
             con.yield(1)
             con.finish()
         }
diff --git a/Tests/PioneerTests/DataStructureTests/BuiltInTypesTests.swift b/Tests/PioneerTests/DataStructureTests/BuiltInTypesTests.swift
index 9bfec8f..9032668 100644
--- a/Tests/PioneerTests/DataStructureTests/BuiltInTypesTests.swift
+++ b/Tests/PioneerTests/DataStructureTests/BuiltInTypesTests.swift
@@ -7,33 +7,33 @@
 //
 
 import Foundation
-import XCTest
-import enum GraphQL.OperationType
 import enum GraphQL.Map
+import enum GraphQL.OperationType
 @testable import Pioneer
+import XCTest
 
 final class BuiltInTypesTests: XCTestCase {
     typealias Req = GraphQLRequest
-    
+
     /// Test ID Randomised features
     func testID() throws {
         let random = ID.random()
         XCTAssert(random.count == 10)
     }
-    
+
     /// Test ID JSON Encoding
     func testIDJSON() throws {
         let myID: ID = "123"
-        
+
         let data = try JSONEncoder().encode(myID)
-    
+
         guard let result = String(data: data, encoding: .utf8) else {
             return XCTFail("Cannot create string from JSON Data")
         }
-        
+
         XCTAssert(result == "\"123\"")
     }
-    
+
     /// Test GraphQLRequest
     func testGraphQLReques() throws {
         let gql0 = Req(query: "query { field1 }")
@@ -42,21 +42,21 @@ final class BuiltInTypesTests: XCTestCase {
             return XCTFail("Cannot idenfity just query")
         }
         XCTAssert(type0 == OperationType.query, "Cannot idenfity just query")
-        
+
         let gql1 = Req(query: "mutation { field1 }")
         XCTAssertFalse(gql1.isIntrospection)
         guard let type1 = gql1.operationType else {
             return XCTFail("Cannot idenfity just mutation")
         }
         XCTAssert(type1 == OperationType.mutation, "Cannot idenfity just mutation")
-        
+
         let gql2 = Req(query: "subscription { field1 }")
         XCTAssertFalse(gql2.isIntrospection)
         guard let type2 = gql2.operationType else {
             return XCTFail("Cannot idenfity just subscription")
         }
         XCTAssert(type2 == OperationType.subscription, "Cannot idenfity just subscription")
-        
+
         let query = "subscription Op0 { field1 } mutation Op1 { field1 } query Op2 { field1 }"
         for (operationName, optype) in [("Op0", OperationType.subscription), ("Op1", OperationType.mutation), ("Op2", OperationType.query)] {
             let gql3 = Req(query: query, operationName: operationName)
@@ -74,7 +74,6 @@ final class BuiltInTypesTests: XCTestCase {
         """.data(using: .utf8)?.to(Req.self)
         XCTAssertEqual(decoded0?.query, "query { field1 }")
 
-
         let decoded1 = """
         {
             "query": "query Name { field1 }",
@@ -104,7 +103,6 @@ final class BuiltInTypesTests: XCTestCase {
         """.data(using: .utf8)?.to(Req.self)
         XCTAssertEqual(decoded3?.query, "query { field1 }")
 
-
         let encoded = Req(query: "query { field }").jsonString
         XCTAssertNotEqual("{}", encoded)
         XCTAssertEqual("{\"query\":\"query { field }\"}", encoded)
diff --git a/Tests/PioneerTests/DataStructureTests/WebSocketProtocolTests.swift b/Tests/PioneerTests/DataStructureTests/WebSocketProtocolTests.swift
index 85aa57c..880142a 100644
--- a/Tests/PioneerTests/DataStructureTests/WebSocketProtocolTests.swift
+++ b/Tests/PioneerTests/DataStructureTests/WebSocketProtocolTests.swift
@@ -5,28 +5,27 @@
 //  Created by d-exclaimation.
 //
 
-import XCTest
 @testable import Pioneer
+import XCTest
 
 final class WebSocketProtocolTests: XCTestCase {
     func testSubProtocolName() {
         XCTAssertEqual(SubscriptionTransportWs.name, "graphql-ws")
         XCTAssertEqual(GraphQLWs.name, "graphql-transport-ws")
     }
-    
+
     func testTypenames() {
         // subscriptions-transport-ws
         XCTAssertEqual(SubscriptionTransportWs.next, "data", "subscriptions-transport-ws's `next` isn't GQL_DATA")
         XCTAssertEqual(SubscriptionTransportWs.complete, "complete", "subscriptions-transport-ws's `complete` isn't GQL_COMPLETE")
         XCTAssertEqual(SubscriptionTransportWs.error, "error", "subscriptions-transport-ws's `error` isn't GQL_ERROR")
-        
-        
+
         // graphql-ws
         XCTAssertEqual(GraphQLWs.next, "next", "graphql-ws's `next` isn't Next")
         XCTAssertEqual(GraphQLWs.complete, "complete", "graphql-ws's `complete` isn't Complete")
         XCTAssertEqual(GraphQLWs.error, "error", "graphql-ws's `error` isn't Error")
     }
-    
+
     func testKeepAliveMessage() {
         XCTAssert(SubscriptionTransportWs.keepAliveMessage.contains("\"ka\""), "subscriptions-transport-ws's keep alive message isn't GQL_CONNECTION_KEEP_ALIVE")
         XCTAssert(GraphQLWs.keepAliveMessage.contains("\"ping\""), "graphql-ws's keep alive message isn't Ping")
diff --git a/Tests/PioneerTests/GraphQLTests/GraphitiAsyncEventStreamTests.swift b/Tests/PioneerTests/GraphQLTests/GraphitiAsyncEventStreamTests.swift
index e8d6e23..d1993e4 100644
--- a/Tests/PioneerTests/GraphQLTests/GraphitiAsyncEventStreamTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/GraphitiAsyncEventStreamTests.swift
@@ -7,11 +7,11 @@
 //
 
 import Foundation
-import XCTest
 import Graphiti
 import GraphQL
 import NIO
 @testable import Pioneer
+import XCTest
 
 /// Simple message type with a custom computed properties
 struct Message: Codable, Identifiable {
@@ -22,7 +22,7 @@ struct Message: Codable, Identifiable {
         var formatting: String
     }
 
-    func description(context: Void, arguments: Arg) async throws -> String {
+    func description(context _: Void, arguments: Arg) async throws -> String {
         switch arguments.formatting.lowercased() {
         case "inline":
             return "msg(\(id)): \(content)"
@@ -40,7 +40,7 @@ struct Message: Codable, Identifiable {
 struct TestResolver {
     let pubsub = AsyncPubSub()
 
-    func hello(context: Void, arguments: NoArguments) -> String {
+    func hello(context _: Void, arguments _: NoArguments) -> String {
         "Hello GraphQL!!"
     }
 
@@ -48,13 +48,13 @@ struct TestResolver {
         var string: String
     }
 
-    func randomMessage(context: Void, arguments: Arg1) async throws -> Message {
+    func randomMessage(context _: Void, arguments: Arg1) async throws -> Message {
         let message = Message(content: arguments.string)
         await pubsub.publish(for: "*", payload: message)
         return message
     }
 
-    func onMessage(context: Void, arguments: NoArguments) -> EventStream<Message> {
+    func onMessage(context _: Void, arguments _: NoArguments) -> EventStream<Message> {
         let stream: AsyncStream<Message> = pubsub.asyncStream(for: "*")
         return stream.toEventStream()
     }
@@ -100,7 +100,7 @@ final class GraphitiTests: XCTestCase {
         }
 
         let start = Date()
-        
+
         let query = """
         subscription {
             onMessage {
@@ -110,7 +110,7 @@ final class GraphitiTests: XCTestCase {
         """
 
         // -- Performing Subscriptions --
-        
+
         let subscriptionResult = try schema
             .subscribe(request: query, resolver: resolver, context: (), eventLoopGroup: group)
             .wait()
@@ -122,21 +122,21 @@ final class GraphitiTests: XCTestCase {
         guard let asyncStream = subscription.asyncStream() else {
             return XCTFail("Stream failed to be casted into proper types \(subscription))")
         }
-        
+
         // -- End --
 
         let expectation = XCTestExpectation(description: "Received a single message")
-        
+
         // -- Consuming stream --
-        
+
         let task = Task.init {
             for try await future in asyncStream {
                 let message = try await future.get()
                 let expected = GraphQLResult(data: [
                     "onMessage": [
                         "id": "bob",
-                        "content": "Bob"
-                    ]
+                        "content": "Bob",
+                    ],
                 ])
                 if message == expected {
                     expectation.fulfill()
@@ -146,7 +146,7 @@ final class GraphitiTests: XCTestCase {
         }
 
         // -- End --
-        
+
         Task.init {
             try await Task.sleep(nanoseconds: 200_000_000)
             await resolver.pubsub.publish(for: "*", payload: Message(id: "bob", content: "Bob"))
diff --git a/Tests/PioneerTests/GraphQLTests/GraphitiExtensionTests.swift b/Tests/PioneerTests/GraphQLTests/GraphitiExtensionTests.swift
index 4e1b609..1b7e755 100644
--- a/Tests/PioneerTests/GraphQLTests/GraphitiExtensionTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/GraphitiExtensionTests.swift
@@ -7,14 +7,13 @@
 //
 
 import Foundation
-import XCTest
-import GraphQL
 import Graphiti
+import GraphQL
 import NIO
 @testable import Pioneer
+import XCTest
 
 final class GraphitiExtensionTests: XCTestCase {
-    
     /// GraphQL Request Object
     /// 1. Should omit nil values
     func testDecodingGraphQLRequest() {
diff --git a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
index bec9030..0b65e89 100644
--- a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
@@ -7,25 +7,25 @@
 //
 
 import Foundation
-import XCTest
-import GraphQL
 import Graphiti
+import GraphQL
 import NIO
 @testable import Pioneer
+import XCTest
 
 struct TestResolver1 {
-    func sync(context: (), arguments: NoArguments) -> Int { 0 }
+    func sync(context _: (), arguments _: NoArguments) -> Int { 0 }
 
     struct Arg0: Codable { var allowed: Bool }
 
-    func syncWithArg(context: (), arguments: Arg0) -> Int { arguments.allowed ? 1 : 0 }
+    func syncWithArg(context _: (), arguments: Arg0) -> Int { arguments.allowed ? 1 : 0 }
 
-    func async(context: (), arguments: NoArguments) async throws -> Int {
+    func async(context _: (), arguments _: NoArguments) async throws -> Int {
         try await Task.sleep(nanoseconds: 1000 * 1000 * 300)
         return 2
     }
 
-    func asyncMessage(context: (), arguments: NoArguments) async throws -> Message {
+    func asyncMessage(context _: (), arguments _: NoArguments) async throws -> Message {
         try await Task.sleep(nanoseconds: 1000 * 1000 * 300)
         return Message(content: "Hello")
     }
@@ -75,14 +75,14 @@ final class PioneerStatelessTests: XCTestCase {
         let gql = [
             "query { sync }",
             "query { syncWithArg(allowed: true) }",
-            "query { async }"
+            "query { async }",
         ].map { GraphQLRequest(query: $0, operationName: nil, variables: nil) }
 
         let expectation = [
             Map.dictionary(["sync": Map.number(0)]),
             ["syncWithArg": .number(1)],
-            ["async": .number(2)]
-        ].map { GraphQLResult.init(data: $0) }
+            ["async": .number(2)],
+        ].map { GraphQLResult(data: $0) }
 
         for i in gql.indices {
             let curr = gql[i]
@@ -91,5 +91,4 @@ final class PioneerStatelessTests: XCTestCase {
             XCTAssertEqual(res, expect)
         }
     }
-
 }
diff --git a/Tests/PioneerTests/OtherTests/ExtensionsTests.swift b/Tests/PioneerTests/OtherTests/ExtensionsTests.swift
index b5446e3..1d0ef3e 100644
--- a/Tests/PioneerTests/OtherTests/ExtensionsTests.swift
+++ b/Tests/PioneerTests/OtherTests/ExtensionsTests.swift
@@ -7,12 +7,12 @@
 //
 
 import Foundation
-import XCTest
-import OrderedCollections
-import NIO
-import Vapor
 import enum GraphQL.Map
+import NIO
+import OrderedCollections
 @testable import Pioneer
+import Vapor
+import XCTest
 
 final class ExtensionsTests: XCTestCase {
     private let app = Application(.testing)
@@ -24,14 +24,14 @@ final class ExtensionsTests: XCTestCase {
             case outcome(expect: XCTestExpectation)
             case none
         }
-        
+
         func call(expect: Task<XCTestExpectation, Error>) {
             pipeToSelf(future: expect) { sink, res in
-                guard case .success(let ex) = res else { return }
+                guard case let .success(ex) = res else { return }
                 await sink.outcome(expect: ex)
             }
         }
-        
+
         func outcome(expect: XCTestExpectation) {
             expect.fulfill()
         }
@@ -55,7 +55,7 @@ final class ExtensionsTests: XCTestCase {
     struct A: Decodable {
         var id: String?
     }
-    
+
     /// JSON String to Structure
     /// 1. Should be able to parse all fields if given
     /// 2. Should be able to infer Optional if not given
@@ -78,7 +78,7 @@ final class ExtensionsTests: XCTestCase {
     /// 2. Should call callback if not found
     func testDictionaryOperation() {
         var isAllowed = false
-        var dict = [String:Int]()
+        var dict = [String: Int]()
         func produce() -> Int {
             XCTAssert(isAllowed)
             return Int.random()
@@ -104,7 +104,7 @@ final class ExtensionsTests: XCTestCase {
         }
         XCTAssert(res1 == 1 && res2 == 2)
     }
-    
+
     /// Bridging between websocket context builder with context builder
     /// 1. Should set the headers and query parameters to the request
     /// 2. Should set the graphql request into request body
@@ -113,8 +113,8 @@ final class ExtensionsTests: XCTestCase {
         let connectionParams = [
             "query": Map.string("verified=true"),
             "headers": Map.dictionary([
-                "auth":  "token"
-            ])
+                "auth": "token",
+            ]),
         ]
         let originalGql = GraphQLRequest(query: "query { someField }")
         do {
@@ -145,26 +145,25 @@ final class ExtensionsTests: XCTestCase {
     /// - Should decode % to its utf-8 characters
     func testPathComponent() {
         let req0 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql/nested1/nested2", 
+            application: app,
+            method: .GET,
+            url: "/graphql/nested1/nested2",
             on: app.eventLoopGroup.next()
         )
         XCTAssert(req0.pathComponents.elementsEqual(["graphql", "nested1", "nested2"]))
 
-
         let req1 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql/nested1/nested2?query=1234&fake=1245", 
+            application: app,
+            method: .GET,
+            url: "/graphql/nested1/nested2?query=1234&fake=1245",
             on: app.eventLoopGroup.next()
         )
         XCTAssert(req1.pathComponents.elementsEqual(["graphql", "nested1", "nested2"]))
 
         let req2 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql%20nested1%20nested2", 
+            application: app,
+            method: .GET,
+            url: "/graphql%20nested1%20nested2",
             on: app.eventLoopGroup.next()
         )
         XCTAssert(req2.pathComponents.elementsEqual(["graphql nested1 nested2"]))
@@ -175,9 +174,9 @@ final class ExtensionsTests: XCTestCase {
     /// - Should be able to matching with .anything and .catchall
     func testPathMatching() {
         let req0 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql/nested1/nested2", 
+            application: app,
+            method: .GET,
+            url: "/graphql/nested1/nested2",
             on: app.eventLoopGroup.next()
         )
         XCTAssertFalse(req0.matching(path: ["graphql"]))
@@ -188,11 +187,10 @@ final class ExtensionsTests: XCTestCase {
         XCTAssert(req0.matching(path: ["graphql", .catchall]))
         XCTAssert(req0.matching(path: [.catchall]))
 
-
         let req1 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql/nested1/nested2?query=1234&fake=1245", 
+            application: app,
+            method: .GET,
+            url: "/graphql/nested1/nested2?query=1234&fake=1245",
             on: app.eventLoopGroup.next()
         )
         XCTAssertFalse(req1.matching(path: ["graphql"]))
@@ -203,9 +201,9 @@ final class ExtensionsTests: XCTestCase {
         XCTAssert(req1.matching(path: [.catchall]))
 
         let req2 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/graphql%20nested1%20nested2", 
+            application: app,
+            method: .GET,
+            url: "/graphql%20nested1%20nested2",
             on: app.eventLoopGroup.next()
         )
         XCTAssert(req2.matching(path: ["graphql nested1 nested2"]))
@@ -215,11 +213,11 @@ final class ExtensionsTests: XCTestCase {
         XCTAssertFalse(req2.matching(path: ["graphql", .anything, "nested2"]))
         XCTAssertFalse(req2.matching(path: ["graphql", .anything, .anything]))
         XCTAssertFalse(req2.matching(path: ["graphql", .catchall]))
-        
+
         let req3 = Request(
-            application: app, 
-            method: .GET, 
-            url: "/", 
+            application: app,
+            method: .GET,
+            url: "/",
             on: app.eventLoopGroup.next()
         )
         XCTAssert(req3.matching(path: [.catchall]))
diff --git a/Tests/PioneerTests/OtherTests/SecurityTest.swift b/Tests/PioneerTests/OtherTests/SecurityTest.swift
index 236af74..e744ab5 100644
--- a/Tests/PioneerTests/OtherTests/SecurityTest.swift
+++ b/Tests/PioneerTests/OtherTests/SecurityTest.swift
@@ -1,14 +1,14 @@
 //  SecurityTest.swift
-//  
+//
 //
 //  Created by d-exclaimation on 25/06/22.
 //
 
 import Foundation
-import Vapor
-import XCTest
 import Graphiti
 @testable import Pioneer
+import Vapor
+import XCTest
 
 final class SecurityTest: XCTestCase {
     private let application = Application(.testing)
@@ -21,11 +21,11 @@ final class SecurityTest: XCTestCase {
         resolver: Resolver(),
         httpStrategy: .csrfPrevention
     )
-    
+
     struct Resolver {
         func hello(_: Void, _: NoArguments) -> String { "Hello" }
     }
-    
+
     /// CSRF Prevention // Protection should
     /// - Return true if protection is inactive
     /// - Return false if protection is active and request has no required headers
@@ -36,19 +36,19 @@ final class SecurityTest: XCTestCase {
         let req = Request(application: application, headers: .init([]), on: application.eventLoopGroup.next())
         let res = pioneer.csrfVulnerable(given: req.headers)
         XCTAssertFalse(res)
-        
+
         let req1 = Request(application: application, headers: .init([("Apollo-Require-Preflight", "True")]), on: application.eventLoopGroup.next())
         let res1 = pioneer.csrfVulnerable(given: req1.headers)
         XCTAssertFalse(res1)
-        
+
         let req2 = Request(application: application, headers: .init([("X-Apollo-Operation-Name", "SomeQuery")]), on: application.eventLoopGroup.next())
         let res2 = pioneer.csrfVulnerable(given: req2.headers)
         XCTAssertFalse(res2)
-        
-        let req3 = Request(application: application, method: .POST,  headers: .init([("Content-Type", "application/json")]), on: application.eventLoopGroup.next())
+
+        let req3 = Request(application: application, method: .POST, headers: .init([("Content-Type", "application/json")]), on: application.eventLoopGroup.next())
         let res3 = pioneer.csrfVulnerable(given: req3.headers)
         XCTAssertFalse(res3)
-        
+
         for unacceptable in ["text/plain", "application/x-www-form-urlencoded", "multipart/form-data"] {
             let req4 = Request(
                 application: application,
@@ -58,7 +58,7 @@ final class SecurityTest: XCTestCase {
             )
             let res4 = pioneer.csrfVulnerable(given: req4.headers)
             XCTAssertTrue(res4)
-            
+
             let req5 = Request(
                 application: application,
                 method: .POST,
@@ -67,7 +67,7 @@ final class SecurityTest: XCTestCase {
             )
             let res5 = pioneer.csrfVulnerable(given: req5.headers)
             XCTAssertFalse(res5)
-            
+
             let req6 = Request(
                 application: application,
                 method: .POST,
diff --git a/Tests/PioneerTests/Utils/TestConsumer.swift b/Tests/PioneerTests/Utils/TestConsumer.swift
index 42217cd..978f5aa 100644
--- a/Tests/PioneerTests/Utils/TestConsumer.swift
+++ b/Tests/PioneerTests/Utils/TestConsumer.swift
@@ -39,7 +39,7 @@ struct TestConsumer: WebSocketable {
         }
     }
 
-    func terminate(code: WebSocketErrorCode) async throws {}
+    func terminate(code _: WebSocketErrorCode) async throws {}
 
     func wait() async -> String {
         await withCheckedContinuation { continuation in
@@ -78,10 +78,9 @@ struct TestConsumer: WebSocketable {
         }
     }
 
-
     func waitThrowing(time: TimeInterval) async -> String? {
         let start = Date()
-        var res = Optional<String>.none
+        var res = String?.none
         while abs(start.timeIntervalSinceNow) < time {
             res = await buffer.pop()
         }
diff --git a/Tests/PioneerTests/VaporTests/ContextTests.swift b/Tests/PioneerTests/VaporTests/ContextTests.swift
index 178c340..d413673 100644
--- a/Tests/PioneerTests/VaporTests/ContextTests.swift
+++ b/Tests/PioneerTests/VaporTests/ContextTests.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 18:06.
 //
 
-import XCTest
 import Graphiti
-import Vapor
 import NIOFoundationCompat
-import XCTVapor
 @testable import Pioneer
+import Vapor
+import XCTest
+import XCTVapor
 
 final class ContextTests: XCTestCase {
     private let server: Pioneer<Resolver, Context> = Pioneer(
@@ -20,7 +20,7 @@ final class ContextTests: XCTestCase {
             Query {
                 Field("test", at: Resolver.test)
             }
-        }, 
+        },
         resolver: .init(),
         httpStrategy: .both,
         introspection: true
@@ -50,7 +50,7 @@ final class ContextTests: XCTestCase {
         app.middleware.use(
             server.vaporMiddleware(
                 at: "graphql",
-                context: { req, res in 
+                context: { req, res in
                     guard let authorization = req.headers[.authorization].first else {
                         throw Abort(.unauthorized, reason: "Cannot authoriza user")
                     }
@@ -63,20 +63,20 @@ final class ContextTests: XCTestCase {
         )
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { test }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)",
             headers: .init([("Authorization", "Bearer Hello")])
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssertEqual(res.headers[.authorization].first, .some("Bearer Hello"))
             XCTAssert(res.body.string.contains("Hello"))
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { test }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .unauthorized)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Tests/PioneerTests/VaporTests/HTTPQueryTests.swift b/Tests/PioneerTests/VaporTests/HTTPQueryTests.swift
index 483093e..ef0cc8d 100644
--- a/Tests/PioneerTests/VaporTests/HTTPQueryTests.swift
+++ b/Tests/PioneerTests/VaporTests/HTTPQueryTests.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 15:56.
 //
 
-import XCTest
 import Graphiti
-import Vapor
 import NIOFoundationCompat
-import XCTVapor
 @testable import Pioneer
+import Vapor
+import XCTest
+import XCTVapor
 
 final class HTTPQueryTests: XCTestCase {
     private let server: Pioneer<Resolver, Void> = Pioneer(
@@ -30,7 +30,7 @@ final class HTTPQueryTests: XCTestCase {
 
                 Field("error", at: Resolver.error)
             }
-        }, 
+        },
         resolver: .init(),
         httpStrategy: .both,
         introspection: true
@@ -47,7 +47,7 @@ final class HTTPQueryTests: XCTestCase {
         }
 
         func randomUsers(_: Void, args: LimitArgs) async -> [User] {
-            (0..<args.limit).map { i in
+            (0 ..< args.limit).map { i in
                 User(id: .init("\(i)"), name: "U\(i)")
             }
         }
@@ -56,7 +56,7 @@ final class HTTPQueryTests: XCTestCase {
             throw Abort(.imATeapot, reason: "Expected")
         }
     }
-    
+
     /// Pioneer when responding to POST request:
     /// - Should respond with proper data when given the proper query
     /// - Should respond with proper data when given query with variables and operation name
@@ -82,20 +82,20 @@ final class HTTPQueryTests: XCTestCase {
         defer {
             app.shutdown()
         }
-        
+
         app.middleware.use(server.vaporMiddleware(), at: .beginning)
 
         let body0 = ByteBuffer(data: gql0.json ?? .init())
-        
+
         try app.testable().test(
-            .POST, "/graphql", 
+            .POST, "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.readableBytes.description)]),
             body: body0
         ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<3 {
+            for i in 0 ..< 3 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
@@ -107,39 +107,39 @@ final class HTTPQueryTests: XCTestCase {
             .POST, "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.readableBytes.description)]),
             body: body1
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<1 {
+            for i in 0 ..< 1 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
         }
 
         let body2 = ByteBuffer(data: gql2.json ?? .init())
-        
+
         try app.testable().test(
             .POST, "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body2.readableBytes.description)]),
             body: body2
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<2 {
+            for i in 0 ..< 2 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
         }
 
         let body3 = ByteBuffer(data: gql3.json ?? .init())
-        
+
         try app.testable().test(
             .POST, "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body3.readableBytes.description)]),
             body: body3
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#""data":{"error":null}"#))
             XCTAssert(res.body.string.contains(#""errors":"#))
@@ -147,12 +147,12 @@ final class HTTPQueryTests: XCTestCase {
         }
 
         let body4 = ByteBuffer(data: gql4.json ?? .init())
-        
+
         try app.testable().test(
             .POST, "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body4.readableBytes.description)]),
             body: body4
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"errors":"#))
         }
@@ -186,38 +186,37 @@ final class HTTPQueryTests: XCTestCase {
 
         app.middleware.use(server.vaporMiddleware(), at: .beginning)
 
-
         try app.testable().test(
             .GET, "/graphql?\(gql0)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<3 {
+            for i in 0 ..< 3 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
         }
 
         try app.testable().test(
-            .GET, "/graphql?\(gql1)" 
-        ) { res in 
+            .GET, "/graphql?\(gql1)"
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<1 {
+            for i in 0 ..< 1 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
         }
 
         try app.testable().test(
-            .GET, "/graphql?\(gql2)" 
-        ) { res in 
+            .GET, "/graphql?\(gql2)"
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"data":{"randomUsers":"#))
             XCTAssertFalse(res.body.string.contains(#""errors":"#))
-            for i in 0..<2 {
+            for i in 0 ..< 2 {
                 XCTAssert(res.body.string.contains("\"id\":\"\(i)\""))
                 XCTAssert(res.body.string.contains("\"name\":\"U\(i)\""))
             }
@@ -225,7 +224,7 @@ final class HTTPQueryTests: XCTestCase {
 
         try app.testable().test(
             .GET, "/graphql?\(gql3)"
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#""data":{"error":null}"#))
             XCTAssert(res.body.string.contains(#""errors":"#))
@@ -234,14 +233,14 @@ final class HTTPQueryTests: XCTestCase {
 
         try app.testable().test(
             .GET, "/graphql?\(gql4)"
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
             XCTAssert(res.body.string.contains(#"{"errors":"#))
         }
 
         try app.testable().test(
             .GET, "/graphql"
-        ) { res in 
+        ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
@@ -251,4 +250,4 @@ final class HTTPQueryTests: XCTestCase {
             XCTAssertEqual(res.status, .notFound)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Tests/PioneerTests/VaporTests/HTTPStrategyTests.swift b/Tests/PioneerTests/VaporTests/HTTPStrategyTests.swift
index 147aebd..8a3dcde 100644
--- a/Tests/PioneerTests/VaporTests/HTTPStrategyTests.swift
+++ b/Tests/PioneerTests/VaporTests/HTTPStrategyTests.swift
@@ -5,12 +5,12 @@
 //  Created by d-exclaimation on 18:35.
 //
 
-import XCTest
 import Graphiti
-import Vapor
 import NIOFoundationCompat
-import XCTVapor
 @testable import Pioneer
+import Vapor
+import XCTest
+import XCTVapor
 
 final class HTTPStrategyTests: XCTestCase {
     private let schema: Schema<Resolver, Void> = try! .init {
@@ -23,6 +23,7 @@ final class HTTPStrategyTests: XCTestCase {
             }
         }
     }
+
     struct Resolver {
         func fetch(_: Void, _: NoArguments) async -> Bool {
             true
@@ -47,23 +48,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .badRequest)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .badRequest)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -74,7 +75,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -93,23 +94,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -120,7 +121,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -139,23 +140,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .badRequest)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -166,7 +167,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -185,23 +186,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -212,7 +213,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -231,23 +232,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .badRequest)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -258,7 +259,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -277,23 +278,23 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -304,7 +305,7 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -323,14 +324,14 @@ final class HTTPStrategyTests: XCTestCase {
         app.middleware.use(server.vaporMiddleware())
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)",
             headers: .init([("Content-Type", "text/plain")])
         ) { res in
@@ -338,7 +339,7 @@ final class HTTPStrategyTests: XCTestCase {
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)",
             headers: .init([("Content-Type", "text/plain"), ("Apollo-Require-Preflight", "true")])
         ) { res in
@@ -346,7 +347,7 @@ final class HTTPStrategyTests: XCTestCase {
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("query Operation { fetch }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)&operationName=Operation",
             headers: .init([("Content-Type", "text/plain"), ("X-Apollo-Operation-Name", "Operation")])
         ) { res in
@@ -354,16 +355,16 @@ final class HTTPStrategyTests: XCTestCase {
         }
 
         try app.testable().test(
-            .GET, 
+            .GET,
             "/graphql?query=\("mutation { update(bool: true) }".addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         ) { res in
             XCTAssertEqual(res.status, .badRequest)
         }
-        
+
         let body0 = ByteBuffer(data: GraphQLRequest(query: "query { fetch }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body0.writableBytes.description)]),
             body: body0
@@ -374,16 +375,16 @@ final class HTTPStrategyTests: XCTestCase {
         let body1 = ByteBuffer(data: GraphQLRequest(query: "mutation { update(bool: true) }").json!)
 
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "application/json"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
         ) { res in
             XCTAssertEqual(res.status, .ok)
         }
-        
+
         try app.testable().test(
-            .POST, 
+            .POST,
             "/graphql",
             headers: .init([("Content-Type", "multipart/form-data"), ("Content-Length", body1.writableBytes.description)]),
             body: body1
@@ -391,4 +392,4 @@ final class HTTPStrategyTests: XCTestCase {
             XCTAssertEqual(res.status, .badRequest)
         }
     }
-}
\ No newline at end of file
+}

From f5e0d0a9ae902f2807c79133ed79cd364ac9ede1 Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Fri, 30 Dec 2022 00:36:17 +1300
Subject: [PATCH 2/6] feat: GraphQLMiddleware implementation

---
 .../GraphQL/Extensions/Field+Middleware.swift | 58 +++++++++++++++++++
 .../Pioneer/GraphQL/GraphQLMiddleware.swift   | 27 +++++++++
 .../GraphQLTests/PioneerStatelessTests.swift  | 27 +++++++++
 3 files changed, 112 insertions(+)
 create mode 100644 Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
 create mode 100644 Sources/Pioneer/GraphQL/GraphQLMiddleware.swift

diff --git a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
new file mode 100644
index 0000000..42101f0
--- /dev/null
+++ b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
@@ -0,0 +1,58 @@
+//
+//  Field+Middleware.swift
+//  pioneer
+//
+//  Created by d-exclaimation on 00:13.
+//
+
+import class Graphiti.Field
+import class Graphiti.ArgumentComponent
+import struct Graphiti.ArgumentComponentBuilder
+import typealias Graphiti.ConcurrentResolve
+
+public extension Field where FieldType: Encodable {
+    convenience init(
+        _ name: String,
+        at function: @escaping ConcurrentResolve<ObjectType, Context, Arguments, FieldType>,
+        use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
+        @ArgumentComponentBuilder<Arguments> _ argument: () -> ArgumentComponent<Arguments>
+    ) {
+        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
+            { context, arguments in
+                let info = ResolverParameters(root: type, context: context, args: arguments)
+                let result = middlewares
+                    .reversed()
+                    .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
+                        return { () async throws -> FieldType in
+                            try await middleware(info, acc)
+                        }
+                    }
+                return try await result()
+            }
+        }
+        self.init(name: name, arguments: [argument()], concurrentResolve: resolve)
+    }
+
+    convenience init(
+        _ name: String,
+        at function: @escaping ConcurrentResolve<ObjectType, Context, Arguments, FieldType>,
+        use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
+        @ArgumentComponentBuilder<Arguments> _ arguments: ()
+            -> [ArgumentComponent<Arguments>] = { [] }
+    ) {
+        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
+            { context, arguments in
+                let info = ResolverParameters(root: type, context: context, args: arguments)
+                let result = middlewares
+                    .reversed()
+                    .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
+                        return { () async throws -> FieldType in
+                            try await middleware(info, acc)
+                        }
+                    }
+                return try await result()
+            }
+        }
+        self.init(name: name, arguments: arguments(), concurrentResolve: resolve)
+    }
+}
\ No newline at end of file
diff --git a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
new file mode 100644
index 0000000..0c88258
--- /dev/null
+++ b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
@@ -0,0 +1,27 @@
+//
+//  GraphQLMiddleware.swift
+//  pioneer
+//
+//  Created by d-exclaimation on 17:38.
+//
+
+/// A struct to group of all parameters for a resolvers 
+public struct ResolverParameters<ObjectType, Context, Arguments> {
+    /// The root element
+    public var root: ObjectType
+    /// The context given for this operation
+    public var context: Context
+    /// The resolver arguments
+    public var args: Arguments
+} 
+
+/// Field resolver middleware specification
+/// 
+/// - Parameters:
+///   - params: The resolver parameters
+///   - next: The next function to be called
+/// - Returns: The return type for the field resolver
+public typealias GraphQLMiddleware<ObjectType, Context, Arguments, FieldType> = (
+    _ params: ResolverParameters<ObjectType, Context, Arguments>,
+    _ next: @escaping () async throws -> FieldType
+) async throws -> FieldType
\ No newline at end of file
diff --git a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
index 0b65e89..e1998c8 100644
--- a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
@@ -25,12 +25,22 @@ struct TestResolver1 {
         return 2
     }
 
+    func asyncWithMiddleware(context _: (), arguments _: NoArguments) async throws -> Bool {
+        false
+    }
+
     func asyncMessage(context _: (), arguments _: NoArguments) async throws -> Message {
         try await Task.sleep(nanoseconds: 1000 * 1000 * 300)
         return Message(content: "Hello")
     }
 }
 
+func AlwaysFail<ObjectType, Arguments>() -> GraphQLMiddleware<ObjectType, Void, Arguments, Bool> {
+    return { info, _ in
+        return true
+    }
+}
+
 final class PioneerStatelessTests: XCTestCase {
     private var group = MultiThreadedEventLoopGroup(numberOfThreads: 4)
     private let resolver = TestResolver1()
@@ -47,6 +57,7 @@ final class PioneerStatelessTests: XCTestCase {
             }
 
             Graphiti.Field("async", at: TestResolver1.async)
+            Graphiti.Field("asyncWithMiddleware", at: TestResolver1.asyncWithMiddleware, use: [AlwaysFail()])
             Graphiti.Field("asyncMessage", at: TestResolver1.asyncMessage)
         }
     }
@@ -91,4 +102,20 @@ final class PioneerStatelessTests: XCTestCase {
             XCTAssertEqual(res, expect)
         }
     }
+
+    /// Pioneer's GraphQLMiddleware 
+    /// 1. Should intercept before the resolver
+    func testMiddleware() async throws { 
+       let gql = GraphQLRequest(
+            query: "query { asyncWithMiddleware }",
+            operationName: nil,
+            variables: nil
+        ) 
+        let expectation = GraphQLResult(data: [
+            "asyncWithMiddleware": .bool(true)
+        ])
+
+        let res = await pioneer.executeOperation(for: gql, with: (), using: group)
+        XCTAssertEqual(res, expectation)
+    }
 }

From 9b24a9744162a58c89cd5e953de715e4d1d3419e Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Fri, 30 Dec 2022 10:45:43 +1300
Subject: [PATCH 3/6] doc: Updated documentation for GraphQL Middleware

---
 Documentation/pages/docs/features/_meta.json  |  3 +-
 .../docs/features/graphql-middleware.mdx      | 84 +++++++++++++++++++
 Documentation/pages/index.mdx                 | 22 +++++
 README.md                                     | 21 +++++
 4 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 Documentation/pages/docs/features/graphql-middleware.mdx

diff --git a/Documentation/pages/docs/features/_meta.json b/Documentation/pages/docs/features/_meta.json
index f5b3dff..39102a9 100644
--- a/Documentation/pages/docs/features/_meta.json
+++ b/Documentation/pages/docs/features/_meta.json
@@ -1,5 +1,6 @@
 {
   "graphql-over-http": "GraphQL over HTTP",
   "graphql-over-websocket": "GraphQL over WebSocket",
-  "graphql-ide": "GraphQL IDE"
+  "graphql-ide": "GraphQL IDE",
+  "graphql-middleware": "GraphQL Middleware"
 }
\ No newline at end of file
diff --git a/Documentation/pages/docs/features/graphql-middleware.mdx b/Documentation/pages/docs/features/graphql-middleware.mdx
new file mode 100644
index 0000000..2def96b
--- /dev/null
+++ b/Documentation/pages/docs/features/graphql-middleware.mdx
@@ -0,0 +1,84 @@
+import { Callout } from 'nextra-theme-docs'
+
+# GraphQL Middleware
+
+<Callout type="warning" emoji="🚧">
+**Work in progress** <br/>
+Resolver-based middleware is still a work in progress. 
+It is currently only supported as extensions to [Graphiti](https://github.com/GraphQLSwift/Graphiti), and only available in `v1.2.0-beta.1` or higher.
+</Callout>
+
+Middleware are useful reusable code that can be easily attached to resolvers. 
+By using middleware we can extract the commonly used code from our resolvers and then declaratively attach it whenever it's needed.
+
+## Creating a middleware
+
+GraphQL middleware is a function that takes 2 arguments:
+ 1. Resolver parameters - _the same as resolvers (root, args, context)_
+ 2. Next function - _used to control the execution of the next middleware and the resolver to which it is attached_
+
+```swift {3,5-6} showLineNumbers copy
+public func Trace<Root, Args, Returned>() -> GraphQLMiddleware<Root, Context, Args, Returned> {
+    return { params, next in
+        let before = Date()
+        let res = try await next()
+        let after = Date()
+        params.ctx.logger.info("Operation takes \(after.timeIntervalSince(before))s")
+        return res
+    }
+}
+```
+
+### Intercepting the resolver
+
+Middleware also has the ability to intercept the result of a resolver's execution.
+
+As an example would be an auth guard:
+
+```swift {3-5} showLineNumbers copy
+public func Auth<Root, Args, Returned>() -> GraphQLMiddleware<Root, Context, Args, Returned> {
+    return { params, next in
+        guard case .some = params.ctx.user else {
+            throw GraphQLError(message: "Not authenticated") 
+        }
+        return try await next()
+    }
+}
+```
+
+Another one would be a cache interceptor:
+
+```swift {5-7} showLineNumbers copy
+public func Cached<Root, Returned: RESPValueConvertible>(
+  key: String
+) -> GraphQLMiddleware<Root, Context, NoArguments, Returned> {
+    return { params, next in
+        guard let cache = try? await redis.get(key, as: Returned.self).get() else {
+          return cache
+        }
+        return try await next()
+    }
+}
+```
+
+## Attaching Middleware
+
+Attaching middlewares can be done through the `use` parameter from `Field`. The order of the middleware is also important.
+
+```swift {4-5,12-13} showLineNumbers copy
+Query {
+    Field("books", 
+        at: Resolver.books, 
+        // Trace -> Cached -> Resolver -> Cached -> Trace
+        use: [Trace(), Cached(key: "query:books")] 
+    )
+}
+
+Mutation {
+    Field("createBook"
+        at: Resolver.createBook,
+        // Auth -> Trace -> Resolver -> Trace -> Auth
+        use: [Auth(), Trace()]
+    )
+}
+```
\ No newline at end of file
diff --git a/Documentation/pages/index.mdx b/Documentation/pages/index.mdx
index d9cbd59..cb367de 100644
--- a/Documentation/pages/index.mdx
+++ b/Documentation/pages/index.mdx
@@ -16,9 +16,31 @@ import Headers from '../components/header'
 .package(url: "https://github.com/d-exclaimation/pioneer", from: "1.0.0")
 ```
 
+### Quick start
+
+```swift showLineNumbers copy
+import Graphiti
+import Pioneer
+
+struct Resolver { ... }
+
+let schema = try Schema<Resolver, Void> { ... }
+
+let server = Pioneer(
+    schema: schema,
+    resolver: .init()
+)
+
+try server.standaloneServer(
+    port: 4000,
+    host: "127.0.0.1"
+)
+```
+
 - [Documentation](https://pioneer.dexclaimation.com/docs)
 - [Getting started](https://pioneer.dexclaimation.com/docs/getting-started)
 - [API References](https://swiftpackageindex.com/d-exclaimation/pioneer/documentation)
+- [GraphQL over HTTP audit report](https://github.com/graphql/graphql-http#servers)
 - [Example](https://github.com/d-exclaimation/pioneer-example)
 
 ### Attribution
diff --git a/README.md b/README.md
index a072212..ed3eca5 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,27 @@ Pioneer is an open-source, [spec-compliant](https://github.com/graphql/graphql-h
 .package(url: "https://github.com/d-exclaimation/pioneer", from: "1.0.0")
 ```
 
+### Quick start
+
+```swift
+import Graphiti
+import Pioneer
+
+struct Resolver { ... }
+
+let schema = try Schema<Resolver, Void> { ... }
+
+let server = Pioneer(
+    schema: schema,
+    resolver: .init()
+)
+
+try server.standaloneServer(
+    port: 4000,
+    host: "127.0.0.1"
+)
+```
+
 ## Usage/Examples
 
 - [Documentation](https://pioneer.dexclaimation.com/docs)

From afe0e23c5e48d301d7f883e3b61c05a504f71ee1 Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Fri, 30 Dec 2022 11:55:36 +1300
Subject: [PATCH 4/6] feat: Middleware on SyncResolve

---
 .../GraphQL/Extensions/Field+Middleware.swift | 50 +++++++++++++++++++
 .../Pioneer/GraphQL/GraphQLMiddleware.swift   | 14 +++---
 .../GraphQLTests/PioneerStatelessTests.swift  | 35 ++++++++-----
 3 files changed, 79 insertions(+), 20 deletions(-)

diff --git a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
index 42101f0..dd2a11b 100644
--- a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
@@ -9,8 +9,58 @@ import class Graphiti.Field
 import class Graphiti.ArgumentComponent
 import struct Graphiti.ArgumentComponentBuilder
 import typealias Graphiti.ConcurrentResolve
+import typealias Graphiti.SyncResolve
 
 public extension Field where FieldType: Encodable {
+    convenience init(
+        _ name: String,
+        at function: @escaping SyncResolve<ObjectType, Context, Arguments, FieldType>,
+        use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
+        @ArgumentComponentBuilder<Arguments> _ argument: () -> ArgumentComponent<Arguments>
+    ) {
+        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
+            { context, arguments in
+                let info = ResolverParameters(root: type, context: context, args: arguments)
+                let result = middlewares
+                    .reversed()
+                    .reduce({ () async throws -> FieldType in 
+                        try function(type)(context, arguments) 
+                    }) { acc, middleware in
+                        return { () async throws -> FieldType in
+                            try await middleware(info, acc)
+                        }
+                    }
+                return try await result()
+            }
+        }
+        self.init(name: name, arguments: [argument()], concurrentResolve: resolve)
+    }
+
+    convenience init(
+        _ name: String,
+        at function: @escaping SyncResolve<ObjectType, Context, Arguments, FieldType>,
+        use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
+        @ArgumentComponentBuilder<Arguments> _ arguments: ()
+            -> [ArgumentComponent<Arguments>] = { [] }
+    ) {
+        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
+            { context, arguments in
+                let info = ResolverParameters(root: type, context: context, args: arguments)
+                let result = middlewares
+                    .reversed()
+                    .reduce({ () async throws -> FieldType in
+                        try function(type)(context, arguments)
+                    }) { acc, middleware in
+                        return { () async throws -> FieldType in
+                            try await middleware(info, acc)
+                        }
+                    }
+                return try await result()
+            }
+        }
+        self.init(name: name, arguments: arguments(), concurrentResolve: resolve)
+    }
+
     convenience init(
         _ name: String,
         at function: @escaping ConcurrentResolve<ObjectType, Context, Arguments, FieldType>,
diff --git a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
index 0c88258..317bf71 100644
--- a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
@@ -6,13 +6,13 @@
 //
 
 /// A struct to group of all parameters for a resolvers 
-public struct ResolverParameters<ObjectType, Context, Arguments> {
+public struct ResolverParameters<Root, Context, Args> {
     /// The root element
-    public var root: ObjectType
+    public var root: Root
     /// The context given for this operation
     public var context: Context
     /// The resolver arguments
-    public var args: Arguments
+    public var args: Args
 } 
 
 /// Field resolver middleware specification
@@ -21,7 +21,7 @@ public struct ResolverParameters<ObjectType, Context, Arguments> {
 ///   - params: The resolver parameters
 ///   - next: The next function to be called
 /// - Returns: The return type for the field resolver
-public typealias GraphQLMiddleware<ObjectType, Context, Arguments, FieldType> = (
-    _ params: ResolverParameters<ObjectType, Context, Arguments>,
-    _ next: @escaping () async throws -> FieldType
-) async throws -> FieldType
\ No newline at end of file
+public typealias GraphQLMiddleware<Root, Context, Args, ResolveType> = (
+    _ params: ResolverParameters<Root, Context, Args>,
+    _ next: @escaping () async throws -> ResolveType
+) async throws -> ResolveType
\ No newline at end of file
diff --git a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
index e1998c8..f91bd8d 100644
--- a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
@@ -25,26 +25,22 @@ struct TestResolver1 {
         return 2
     }
 
-    func asyncWithMiddleware(context _: (), arguments _: NoArguments) async throws -> Bool {
-        false
-    }
-
     func asyncMessage(context _: (), arguments _: NoArguments) async throws -> Message {
         try await Task.sleep(nanoseconds: 1000 * 1000 * 300)
         return Message(content: "Hello")
     }
 }
 
-func AlwaysFail<ObjectType, Arguments>() -> GraphQLMiddleware<ObjectType, Void, Arguments, Bool> {
+func AlwaysFail<ObjectType, Arguments>() -> GraphQLMiddleware<ObjectType, Void, Arguments, Int> {
     return { info, _ in
-        return true
+        return 0
     }
 }
 
 final class PioneerStatelessTests: XCTestCase {
     private var group = MultiThreadedEventLoopGroup(numberOfThreads: 4)
     private let resolver = TestResolver1()
-    private let schema = try! Schema<TestResolver1, Void>.init {
+    private let schema = try! Schema<TestResolver1, Void> {
         Graphiti.Type(Message.self) {
             Graphiti.Field("id", at: \.id)
             Graphiti.Field("id", at: \.content)
@@ -52,12 +48,13 @@ final class PioneerStatelessTests: XCTestCase {
 
         Graphiti.Query {
             Graphiti.Field("sync", at: TestResolver1.sync)
+            Graphiti.Field("syncWithMiddleware", at: TestResolver1.sync, use: [AlwaysFail()])
             Graphiti.Field("syncWithArg", at: TestResolver1.syncWithArg) {
                 Graphiti.Argument("allowed", at: \.allowed)
             }
 
             Graphiti.Field("async", at: TestResolver1.async)
-            Graphiti.Field("asyncWithMiddleware", at: TestResolver1.asyncWithMiddleware, use: [AlwaysFail()])
+            Graphiti.Field("asyncWithMiddleware", at: TestResolver1.async, use: [AlwaysFail()])
             Graphiti.Field("asyncMessage", at: TestResolver1.asyncMessage)
         }
     }
@@ -106,16 +103,28 @@ final class PioneerStatelessTests: XCTestCase {
     /// Pioneer's GraphQLMiddleware 
     /// 1. Should intercept before the resolver
     func testMiddleware() async throws { 
-       let gql = GraphQLRequest(
+        let gql0 = GraphQLRequest(
+            query: "query { syncWithMiddleware }",
+            operationName: nil,
+            variables: nil
+        ) 
+        let exp0 = GraphQLResult(data: [
+            "syncWithMiddleware": .int(0)
+        ])
+
+        let res0 = await pioneer.executeOperation(for: gql0, with: (), using: group)
+        XCTAssertEqual(res0, exp0)
+
+       let gql1 = GraphQLRequest(
             query: "query { asyncWithMiddleware }",
             operationName: nil,
             variables: nil
         ) 
-        let expectation = GraphQLResult(data: [
-            "asyncWithMiddleware": .bool(true)
+        let exp1 = GraphQLResult(data: [
+            "asyncWithMiddleware": .int(0)
         ])
 
-        let res = await pioneer.executeOperation(for: gql, with: (), using: group)
-        XCTAssertEqual(res, expectation)
+        let res1 = await pioneer.executeOperation(for: gql1, with: (), using: group)
+        XCTAssertEqual(res1, exp1)
     }
 }

From d37095b0094ed6d53ef3e18312d160d4ef134933 Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Fri, 30 Dec 2022 12:01:38 +1300
Subject: [PATCH 5/6] fix; Format code

---
 .../GraphQL/Extensions/Field+Middleware.swift  | 16 ++++++++--------
 .../Pioneer/GraphQL/GraphQLMiddleware.swift    |  8 ++++----
 .../GraphQLTests/PioneerStatelessTests.swift   | 18 +++++++++---------
 3 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
index dd2a11b..e1ab237 100644
--- a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
@@ -5,10 +5,10 @@
 //  Created by d-exclaimation on 00:13.
 //
 
-import class Graphiti.Field
 import class Graphiti.ArgumentComponent
 import struct Graphiti.ArgumentComponentBuilder
 import typealias Graphiti.ConcurrentResolve
+import class Graphiti.Field
 import typealias Graphiti.SyncResolve
 
 public extension Field where FieldType: Encodable {
@@ -23,10 +23,10 @@ public extension Field where FieldType: Encodable {
                 let info = ResolverParameters(root: type, context: context, args: arguments)
                 let result = middlewares
                     .reversed()
-                    .reduce({ () async throws -> FieldType in 
-                        try function(type)(context, arguments) 
+                    .reduce({ () async throws -> FieldType in
+                        try function(type)(context, arguments)
                     }) { acc, middleware in
-                        return { () async throws -> FieldType in
+                        { () async throws -> FieldType in
                             try await middleware(info, acc)
                         }
                     }
@@ -51,7 +51,7 @@ public extension Field where FieldType: Encodable {
                     .reduce({ () async throws -> FieldType in
                         try function(type)(context, arguments)
                     }) { acc, middleware in
-                        return { () async throws -> FieldType in
+                        { () async throws -> FieldType in
                             try await middleware(info, acc)
                         }
                     }
@@ -73,7 +73,7 @@ public extension Field where FieldType: Encodable {
                 let result = middlewares
                     .reversed()
                     .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
-                        return { () async throws -> FieldType in
+                        { () async throws -> FieldType in
                             try await middleware(info, acc)
                         }
                     }
@@ -96,7 +96,7 @@ public extension Field where FieldType: Encodable {
                 let result = middlewares
                     .reversed()
                     .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
-                        return { () async throws -> FieldType in
+                        { () async throws -> FieldType in
                             try await middleware(info, acc)
                         }
                     }
@@ -105,4 +105,4 @@ public extension Field where FieldType: Encodable {
         }
         self.init(name: name, arguments: arguments(), concurrentResolve: resolve)
     }
-}
\ No newline at end of file
+}
diff --git a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
index 317bf71..9f6bf6c 100644
--- a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
@@ -5,7 +5,7 @@
 //  Created by d-exclaimation on 17:38.
 //
 
-/// A struct to group of all parameters for a resolvers 
+/// A struct to group of all parameters for a resolvers
 public struct ResolverParameters<Root, Context, Args> {
     /// The root element
     public var root: Root
@@ -13,10 +13,10 @@ public struct ResolverParameters<Root, Context, Args> {
     public var context: Context
     /// The resolver arguments
     public var args: Args
-} 
+}
 
 /// Field resolver middleware specification
-/// 
+///
 /// - Parameters:
 ///   - params: The resolver parameters
 ///   - next: The next function to be called
@@ -24,4 +24,4 @@ public struct ResolverParameters<Root, Context, Args> {
 public typealias GraphQLMiddleware<Root, Context, Args, ResolveType> = (
     _ params: ResolverParameters<Root, Context, Args>,
     _ next: @escaping () async throws -> ResolveType
-) async throws -> ResolveType
\ No newline at end of file
+) async throws -> ResolveType
diff --git a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
index f91bd8d..69219c4 100644
--- a/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
+++ b/Tests/PioneerTests/GraphQLTests/PioneerStatelessTests.swift
@@ -32,8 +32,8 @@ struct TestResolver1 {
 }
 
 func AlwaysFail<ObjectType, Arguments>() -> GraphQLMiddleware<ObjectType, Void, Arguments, Int> {
-    return { info, _ in
-        return 0
+    return { _, _ in
+        0
     }
 }
 
@@ -100,28 +100,28 @@ final class PioneerStatelessTests: XCTestCase {
         }
     }
 
-    /// Pioneer's GraphQLMiddleware 
+    /// Pioneer's GraphQLMiddleware
     /// 1. Should intercept before the resolver
-    func testMiddleware() async throws { 
+    func testMiddleware() async throws {
         let gql0 = GraphQLRequest(
             query: "query { syncWithMiddleware }",
             operationName: nil,
             variables: nil
-        ) 
+        )
         let exp0 = GraphQLResult(data: [
-            "syncWithMiddleware": .int(0)
+            "syncWithMiddleware": .int(0),
         ])
 
         let res0 = await pioneer.executeOperation(for: gql0, with: (), using: group)
         XCTAssertEqual(res0, exp0)
 
-       let gql1 = GraphQLRequest(
+        let gql1 = GraphQLRequest(
             query: "query { asyncWithMiddleware }",
             operationName: nil,
             variables: nil
-        ) 
+        )
         let exp1 = GraphQLResult(data: [
-            "asyncWithMiddleware": .int(0)
+            "asyncWithMiddleware": .int(0),
         ])
 
         let res1 = await pioneer.executeOperation(for: gql1, with: (), using: group)

From b4667912bbfb0dcba95559183e1fd454e7f463d7 Mon Sep 17 00:00:00 2001
From: Vincent <thisoneis4business@gmail.com>
Date: Fri, 30 Dec 2022 14:31:52 +1300
Subject: [PATCH 6/6] chore: Cleanup code and documentation

---
 .../docs/features/graphql-middleware.mdx      | 35 ++++----
 Sources/Pioneer/GraphQL/BuiltinTypes.swift    |  2 +-
 .../GraphQL/Extensions/Field+Middleware.swift | 80 +++++--------------
 Sources/Pioneer/GraphQL/GraphQLMessage.swift  |  4 +-
 .../Pioneer/GraphQL/GraphQLMiddleware.swift   | 51 ++++++++++++
 Sources/Pioneer/GraphQL/GraphQLRequest.swift  |  6 +-
 Sources/Pioneer/Http/HTTPGraphQL.swift        |  9 ++-
 .../Request/Request+GraphQLRequest.swift      | 12 ++-
 Sources/Pioneer/Vapor/Http/Pioneer+Http.swift |  4 +-
 9 files changed, 113 insertions(+), 90 deletions(-)

diff --git a/Documentation/pages/docs/features/graphql-middleware.mdx b/Documentation/pages/docs/features/graphql-middleware.mdx
index 2def96b..4faaadd 100644
--- a/Documentation/pages/docs/features/graphql-middleware.mdx
+++ b/Documentation/pages/docs/features/graphql-middleware.mdx
@@ -8,16 +8,25 @@ Resolver-based middleware is still a work in progress.
 It is currently only supported as extensions to [Graphiti](https://github.com/GraphQLSwift/Graphiti), and only available in `v1.2.0-beta.1` or higher.
 </Callout>
 
-Middleware are useful reusable code that can be easily attached to resolvers. 
-By using middleware we can extract the commonly used code from our resolvers and then declaratively attach it whenever it's needed.
+Middlewares are useful reusable code that can be easily attached to resolvers.
+It allows you to perform operations on incoming operations before they get to the field resolver and on outgoing responses before they are sent back.
 
 ## Creating a middleware
 
 GraphQL middleware is a function that takes 2 arguments:
- 1. Resolver parameters - _the same as resolvers (root, args, context)_
- 2. Next function - _used to control the execution of the next middleware and the resolver to which it is attached_
+ 1. Resolver parameters - _All information given to the resolver (root, args, context)_
+ 2. Next function - _Function to control the execution of the next middleware and the resolver to which it is attached_
+
+```swift {5} showLineNumbers copy filename="Specific resolver middleware"
+public func MinZeroResult(
+    params: ResolverParameters<Resolver, Context, NoArguments>,
+    next: @escaping () -> Int
+) async throws -> Int {
+    try await min(next(), 0)
+}
+```
 
-```swift {3,5-6} showLineNumbers copy
+```swift {3,5-6} showLineNumbers copy filename="Reusable generic middleware"
 public func Trace<Root, Args, Returned>() -> GraphQLMiddleware<Root, Context, Args, Returned> {
     return { params, next in
         let before = Date()
@@ -65,20 +74,14 @@ public func Cached<Root, Returned: RESPValueConvertible>(
 
 Attaching middlewares can be done through the `use` parameter from `Field`. The order of the middleware is also important.
 
-```swift {4-5,12-13} showLineNumbers copy
+```swift {3,8} showLineNumbers copy
 Query {
-    Field("books", 
-        at: Resolver.books, 
-        // Trace -> Cached -> Resolver -> Cached -> Trace
-        use: [Trace(), Cached(key: "query:books")] 
-    )
+    // Trace -> Cached -> Resolver
+    Field("books", at: Resolver.books, use: [Trace(), Cached(key: "query:books")])
 }
 
 Mutation {
-    Field("createBook"
-        at: Resolver.createBook,
-        // Auth -> Trace -> Resolver -> Trace -> Auth
-        use: [Auth(), Trace()]
-    )
+    // Auth -> Trace -> Resolver 
+    Field("createBook", at: Resolver.createBook, use: [Auth(), Trace()])
 }
 ```
\ No newline at end of file
diff --git a/Sources/Pioneer/GraphQL/BuiltinTypes.swift b/Sources/Pioneer/GraphQL/BuiltinTypes.swift
index feabba3..de0065e 100644
--- a/Sources/Pioneer/GraphQL/BuiltinTypes.swift
+++ b/Sources/Pioneer/GraphQL/BuiltinTypes.swift
@@ -85,7 +85,7 @@ public struct ID: Codable, ExpressibleByStringLiteral, CustomStringConvertible,
     }
 
     /// Conversion Error for the ID scalar
-    public struct ConversionError: Error {
+    public struct ConversionError: Error, @unchecked Sendable {
         /// The ID in question as string
         public var id: String
 
diff --git a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
index e1ab237..fdf86ad 100644
--- a/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
+++ b/Sources/Pioneer/GraphQL/Extensions/Field+Middleware.swift
@@ -18,22 +18,11 @@ public extension Field where FieldType: Encodable {
         use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
         @ArgumentComponentBuilder<Arguments> _ argument: () -> ArgumentComponent<Arguments>
     ) {
-        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
-            { context, arguments in
-                let info = ResolverParameters(root: type, context: context, args: arguments)
-                let result = middlewares
-                    .reversed()
-                    .reduce({ () async throws -> FieldType in
-                        try function(type)(context, arguments)
-                    }) { acc, middleware in
-                        { () async throws -> FieldType in
-                            try await middleware(info, acc)
-                        }
-                    }
-                return try await result()
-            }
-        }
-        self.init(name: name, arguments: [argument()], concurrentResolve: resolve)
+        self.init(
+            name: name,
+            arguments: [argument()],
+            concurrentResolve: buildResolver(from: function, using: middlewares)
+        )
     }
 
     convenience init(
@@ -43,22 +32,11 @@ public extension Field where FieldType: Encodable {
         @ArgumentComponentBuilder<Arguments> _ arguments: ()
             -> [ArgumentComponent<Arguments>] = { [] }
     ) {
-        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
-            { context, arguments in
-                let info = ResolverParameters(root: type, context: context, args: arguments)
-                let result = middlewares
-                    .reversed()
-                    .reduce({ () async throws -> FieldType in
-                        try function(type)(context, arguments)
-                    }) { acc, middleware in
-                        { () async throws -> FieldType in
-                            try await middleware(info, acc)
-                        }
-                    }
-                return try await result()
-            }
-        }
-        self.init(name: name, arguments: arguments(), concurrentResolve: resolve)
+        self.init(
+            name: name,
+            arguments: arguments(),
+            concurrentResolve: buildResolver(from: function, using: middlewares)
+        )
     }
 
     convenience init(
@@ -67,20 +45,11 @@ public extension Field where FieldType: Encodable {
         use middlewares: [GraphQLMiddleware<ObjectType, Context, Arguments, FieldType>],
         @ArgumentComponentBuilder<Arguments> _ argument: () -> ArgumentComponent<Arguments>
     ) {
-        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
-            { context, arguments in
-                let info = ResolverParameters(root: type, context: context, args: arguments)
-                let result = middlewares
-                    .reversed()
-                    .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
-                        { () async throws -> FieldType in
-                            try await middleware(info, acc)
-                        }
-                    }
-                return try await result()
-            }
-        }
-        self.init(name: name, arguments: [argument()], concurrentResolve: resolve)
+        self.init(
+            name: name,
+            arguments: [argument()],
+            concurrentResolve: buildResolver(from: function, using: middlewares)
+        )
     }
 
     convenience init(
@@ -90,19 +59,10 @@ public extension Field where FieldType: Encodable {
         @ArgumentComponentBuilder<Arguments> _ arguments: ()
             -> [ArgumentComponent<Arguments>] = { [] }
     ) {
-        let resolve: ConcurrentResolve<ObjectType, Context, Arguments, FieldType> = { type in
-            { context, arguments in
-                let info = ResolverParameters(root: type, context: context, args: arguments)
-                let result = middlewares
-                    .reversed()
-                    .reduce({ try await function(type)(context, arguments) }) { acc, middleware in
-                        { () async throws -> FieldType in
-                            try await middleware(info, acc)
-                        }
-                    }
-                return try await result()
-            }
-        }
-        self.init(name: name, arguments: arguments(), concurrentResolve: resolve)
+        self.init(
+            name: name,
+            arguments: arguments(),
+            concurrentResolve: buildResolver(from: function, using: middlewares)
+        )
     }
 }
diff --git a/Sources/Pioneer/GraphQL/GraphQLMessage.swift b/Sources/Pioneer/GraphQL/GraphQLMessage.swift
index 40e8ee1..fe7bef0 100644
--- a/Sources/Pioneer/GraphQL/GraphQLMessage.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLMessage.swift
@@ -9,7 +9,7 @@ import Foundation
 import GraphQL
 
 /// GraphQL Websocket Message according to all sub-protocol
-public struct GraphQLMessage: Codable {
+public struct GraphQLMessage: Codable, @unchecked Sendable {
     /// Operation based ID if any
     public var id: String?
     /// Message type specified to allow differentiation
@@ -44,7 +44,7 @@ public struct GraphQLMessage: Codable {
     }
 
     /// Variant type to escape constraint on payload, use only for cases where certain payload break the object spec
-    public struct Variance: Codable {
+    public struct Variance: Codable, @unchecked Sendable {
         public var id: String?
         public var type: String
         public var payload: Map?
diff --git a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
index 9f6bf6c..57d63ff 100644
--- a/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLMiddleware.swift
@@ -5,6 +5,9 @@
 //  Created by d-exclaimation on 17:38.
 //
 
+import typealias Graphiti.ConcurrentResolve
+import typealias Graphiti.SyncResolve
+
 /// A struct to group of all parameters for a resolvers
 public struct ResolverParameters<Root, Context, Args> {
     /// The root element
@@ -25,3 +28,51 @@ public typealias GraphQLMiddleware<Root, Context, Args, ResolveType> = (
     _ params: ResolverParameters<Root, Context, Args>,
     _ next: @escaping () async throws -> ResolveType
 ) async throws -> ResolveType
+
+/// Build a single resolver with a single base resolver and a handful middlewares
+/// - Parameters:
+///   - function: The base resolver 
+///   - middlewares: The middlewares to wrap the resolvers
+/// - Returns: A single resolver with middleware applied
+public func buildResolver<Root, Context, Args, ResolveType>(
+    from function: @escaping SyncResolve<Root, Context, Args, ResolveType>,
+    using middlewares: [GraphQLMiddleware<Root, Context, Args, ResolveType>]
+) -> ConcurrentResolve<Root, Context, Args, ResolveType> {
+   { root in
+        { ctx, args in
+            let info = ResolverParameters(root: root, context: ctx, args: args)
+            let result = middlewares
+                .reversed()
+                .reduce({ () async throws in try function(root)(ctx, args) }) { next, middleware in
+                    { () async throws in
+                        try await middleware(info, next)
+                    }
+                }
+            return try await result()
+        }
+   }
+}
+
+/// Build a single resolver with a single base resolver and a handful middlewares
+/// - Parameters:
+///   - function: The base async resolver 
+///   - middlewares: The middlewares to wrap the resolvers
+/// - Returns: A single resolver with middleware applied
+public func buildResolver<Root, Context, Args, ResolveType>(
+    from function: @escaping ConcurrentResolve<Root, Context, Args, ResolveType>,
+    using middlewares: [GraphQLMiddleware<Root, Context, Args, ResolveType>]
+) -> ConcurrentResolve<Root, Context, Args, ResolveType> {
+   { root in
+        { ctx, args in
+            let info = ResolverParameters(root: root, context: ctx, args: args)
+            let result = middlewares
+                .reversed()
+                .reduce({ try await function(root)(ctx, args) }) { next, middleware in
+                    { () async throws in
+                        try await middleware(info, next)
+                    }
+                }
+            return try await result()
+        }
+   }
+}
diff --git a/Sources/Pioneer/GraphQL/GraphQLRequest.swift b/Sources/Pioneer/GraphQL/GraphQLRequest.swift
index 57bc440..58cc2aa 100644
--- a/Sources/Pioneer/GraphQL/GraphQLRequest.swift
+++ b/Sources/Pioneer/GraphQL/GraphQLRequest.swift
@@ -9,7 +9,7 @@ import Foundation
 import GraphQL
 
 /// GraphQL Request according to the spec
-public struct GraphQLRequest: Codable {
+public struct GraphQLRequest: Codable, @unchecked Sendable {
     private enum Key: String, CodingKey, CaseIterable {
         case query, operationName, variables, extensions
     }
@@ -105,11 +105,11 @@ public struct GraphQLRequest: Codable {
     }
 
     /// Known possible failure in parsing GraphQLRequest
-    public enum ParsingIssue: Error {
+    public enum ParsingIssue: Error, @unchecked Sendable {
         case missingQuery
         case invalidForm
     }
 
     /// GraphQL over HTTP spec accept-type
-    static var acceptType = "application/graphql-response+json"
+    static var mediaType = "application/graphql-response+json"
 }
diff --git a/Sources/Pioneer/Http/HTTPGraphQL.swift b/Sources/Pioneer/Http/HTTPGraphQL.swift
index 4f65bb2..f2c53a1 100644
--- a/Sources/Pioneer/Http/HTTPGraphQL.swift
+++ b/Sources/Pioneer/Http/HTTPGraphQL.swift
@@ -14,7 +14,7 @@ import enum NIOHTTP1.HTTPResponseStatus
 
 public extension Pioneer {
     /// HTTP-based GraphQL Response
-    struct HTTPGraphQLResponse {
+    struct HTTPGraphQLResponse: @unchecked Sendable {
         /// GraphQL Result for this response
         public var result: GraphQLResult
 
@@ -33,7 +33,7 @@ public extension Pioneer {
     }
 
     /// HTTP-based GraphQL request
-    struct HTTPGraphQLRequest {
+    struct HTTPGraphQLRequest: Sendable {
         /// GraphQL Request for this request
         public var request: GraphQLRequest
 
@@ -60,5 +60,10 @@ public extension Pioneer {
             self.headers = headers
             self.method = method
         }
+
+        /// Is request accepting GraphQL media type
+        public var isAcceptingGraphQLResponse: Bool {
+            self.headers[.accept].contains(GraphQLRequest.mediaType)
+        }
     }
 }
diff --git a/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift b/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
index e98db7b..9e14491 100644
--- a/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
+++ b/Sources/Pioneer/Vapor/Extensions/Request/Request+GraphQLRequest.swift
@@ -27,17 +27,16 @@ public extension Request {
                 return GraphQLRequest(query: query, operationName: operationName, variables: variables)
 
             case .POST:
-                let accept = self.headers[.accept]
-                guard !self.headers[.contentType].isEmpty else {
+                guard !headers[.contentType].isEmpty else {
                     throw Abort(.badRequest, reason: "Invalid content-type")
                 }
                 do {
                     return try self.content.decode(GraphQLRequest.self)
                 } catch GraphQLRequest.ParsingIssue.missingQuery {
-                    throw Abort(accept.contains(GraphQLRequest.acceptType) ? .badRequest : .ok,
+                    throw Abort(isAcceptingGraphQLResponse ? .badRequest : .ok,
                                 reason: "Missing query parameter")
                 } catch GraphQLRequest.ParsingIssue.invalidForm {
-                    throw Abort(accept.contains(GraphQLRequest.acceptType) ? .badRequest : .ok,
+                    throw Abort(isAcceptingGraphQLResponse ? .badRequest : .ok,
                                 reason: "Invalid GraphQL request form")
                 } catch {
                     throw Abort(.badRequest, reason: "Unable to parse JSON")
@@ -48,4 +47,9 @@ public extension Request {
             }
         }
     }
+
+    /// Is request accepting GraphQL media type
+    var isAcceptingGraphQLResponse: Bool {
+        headers[.accept].contains(GraphQLRequest.mediaType)
+    }
 }
diff --git a/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift b/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
index 553b17f..48b19e1 100644
--- a/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
+++ b/Sources/Pioneer/Vapor/Http/Pioneer+Http.swift
@@ -40,8 +40,8 @@ public extension Pioneer {
             try res.content.encode(httpRes.result, using: encoder)
             res.status = httpRes.status
 
-            if req.headers[.accept].contains(GraphQLRequest.acceptType) {
-                res.headers.replaceOrAdd(name: .contentType, value: "\(GraphQLRequest.acceptType); charset=utf-8, \(GraphQLRequest.acceptType)")
+            if httpReq.isAcceptingGraphQLResponse {
+                res.headers.replaceOrAdd(name: .contentType, value: "\(GraphQLRequest.mediaType); charset=utf-8, \(GraphQLRequest.mediaType)")
             }
             return res
         } catch let error as AbortError {