Merge pull request #166 from NeedleInAJayStack/feat/swift-concurrency

Breaking: Converts to Swift Concurrency

Author: NeedleInAJayStack

MIGRATION.md

@@ -1,6 +1,62 @@
 # Migration
 
-## 2.0 to 3.0
+## 3 to 4
+
+### NIO removal
+
+All NIO-based arguments and return types were removed, including all `EventLoopGroup` and `EventLoopFuture` parameters.
+
+As such, all `execute` and `subscribe` calls should have the `eventLoopGroup` argument removed, and the `await` keyword should be used.
+
+Also, all resolver closures must remove the `eventLoopGroup` argument, and all that return an `EventLoopFuture` should be converted to an `async` function.
+
+The documentation here will be very helpful in the conversion: https://www.swift.org/documentation/server/guides/libraries/concurrency-adoption-guidelines.html
+
+### Swift Concurrency checking
+
+With the conversion from NIO to Swift Concurrency, types used across async boundaries should conform to `Sendable` to avoid errors and warnings. This includes the Swift types and functions that back the GraphQL schema. For more details on the conversion, see the [Sendable documentation](https://developer.apple.com/documentation/swift/sendable).
+
+### `ExecutionStrategy` argument removals
+
+The `queryStrategy`, `mutationStrategy`, and `subscriptionStrategy` arguments have been removed from `graphql` and `graphqlSubscribe`. Instead Queries and Subscriptions are executed in parallel and Mutations are executed serially, [as required by the spec](https://spec.graphql.org/October2021/#sec-Mutation).
+
+### `validationRules` argument reorder
+
+The `validationRules` argument has been moved from the beginning of  `graphql` and `graphqlSubscribe` to the end to better reflect its relative importance:
+
+
+```swift
+// Before
+let result = try await graphql(
+    validationRules: [ruleABC],
+    schema: schema,
+    ...
+)
+// After
+let result = try await graphql(
+    schema: schema,
+    ...
+    validationRules: [ruleABC]
+)
+```
+
+### EventStream removal
+
+The `EventStream` abstraction used to provide pre-concurrency subscription support has been removed. This means that `graphqlSubscribe(...).stream` will now be an `AsyncThrowingStream<GraphQLResult, Error>` type, instead of an `EventStream` type, and that downcasting to `ConcurrentEventStream` is no longer necessary.
+
+### SubscriptionResult removal
+
+The `SubscriptionResult` type was removed, and `graphqlSubscribe` now returns `Result<AsyncThrowingStream<GraphQLResult, Error>, GraphQLErrors>`.
+
+### Instrumentation removal
+
+The `Instrumentation` type has been removed, with anticipated support for tracing using [`swift-distributed-tracing`](https://github.com/apple/swift-distributed-tracing). `instrumentation` arguments must be removed from `graphql` and `graphqlSubscribe` calls.
+
+### AST Node `set`
+
+The deprecated `Node.set(value: Node?, key: String)` function was removed in preference of the `Node.set(value _: NodeResult?, key _: String)`. Change any calls from `node.set(value: node, key: string)` to `node.set(.node(node), string)`.
+
+## 2 to 3
 
 ### TypeReference removal
 
@@ -73,4 +129,4 @@ The following type properties were changed from arrays to closures. To get the a
 
 ### GraphQL type codability
 
-With GraphQL type definitions now including closures, many of the objects in [Definition](https://github.com/GraphQLSwift/GraphQL/blob/main/Sources/GraphQL/Type/Definition.swift) are no longer codable. If you are depending on codability, you can conform the type appropriately in your downstream package.
+With GraphQL type definitions now including closures, many of the objects in [Definition](https://github.com/GraphQLSwift/GraphQL/blob/main/Sources/GraphQL/Type/Definition.swift) are no longer codable. If you are depending on codability, you can conform the type appropriately in your downstream package.

Package.resolved

@@ -3,18 +3,17 @@ import PackageDescription
 
 let package = Package(
     name: "GraphQL",
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v6)],
     products: [
         .library(name: "GraphQL", targets: ["GraphQL"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.10.1")),
         .package(url: "https://github.com/apple/swift-collections", .upToNextMajor(from: "1.0.0")),
     ],
     targets: [
         .target(
             name: "GraphQL",
             dependencies: [
-                .product(name: "NIO", package: "swift-nio"),
                 .product(name: "OrderedCollections", package: "swift-collections"),
             ]
         ),
@@ -26,5 +25,6 @@ let package = Package(
                 .copy("LanguageTests/schema-kitchen-sink.graphql"),
             ]
         ),
-    ]
+    ],
+    swiftLanguageVersions: [.v5, .version("6")]
 )

Package.swift

@@ -45,8 +45,7 @@ Once a schema has been defined queries may be executed against it using the glob
 ```swift
 let result = try await graphql(
     schema: schema,
-    request: "{ hello }",
-    eventLoopGroup: eventLoopGroup
+    request: "{ hello }"
 )
 ```
 
@@ -58,33 +57,29 @@ The result of this query is a `GraphQLResult` that encodes to the following JSON
 
 ### Subscription
 
-This package supports GraphQL subscription, but until the integration of `AsyncSequence` in Swift 5.5 the standard Swift library did not
-provide an event-stream construct. For historical reasons and backwards compatibility, this library implements subscriptions using an 
-`EventStream` protocol that nearly every asynchronous stream implementation can conform to.
-
-To create a subscription field in a GraphQL schema, use the `subscribe` resolver that returns an `EventStream`. You must also provide a
-`resolver`, which defines how to process each event as it occurs and must return the field result type. Here is an example:
+This package supports GraphQL subscription. To create a subscription field in a GraphQL schema, use the `subscribe`
+resolver that returns any type that conforms to `AsyncSequence`. You must also provide a `resolver`, which defines how
+to process each event as it occurs and must return the field result type. Here is an example:
 
 ```swift
 let schema = try GraphQLSchema(
     subscribe: GraphQLObjectType(
         name: "Subscribe",
         fields: [
-            "hello": GraphQLField(              
+            "hello": GraphQLField(
                 type: GraphQLString,
-                resolve: { eventResult, _, _, _, _ in       // Defines how to transform each event when it occurs
+                resolve: { eventResult, _, _, _ in       // Defines how to transform each event when it occurs
                     return eventResult
                 },
-                subscribe: { _, _, _, _, _ in               // Defines how to construct the event stream
-                    let asyncStream = AsyncThrowingStream<String, Error> { continuation in
+                subscribe: { _, _, _, _ in               // Defines how to construct the event stream
+                    return AsyncThrowingStream<String, Error> { continuation in
                         let timer = Timer.scheduledTimer(
                             withTimeInterval: 3,
                             repeats: true,
                         ) {
-                            continuation.yield("world")     // Emits "world" every 3 seconds
+                            continuation.yield("world")  // Emits "world" every 3 seconds
                         }
                     }
-                    return ConcurrentEventStream<String>(asyncStream)
                 }
             )
         ]
@@ -98,9 +93,8 @@ To execute a subscription use the `graphqlSubscribe` function:
 let subscriptionResult = try await graphqlSubscribe(
     schema: schema,
 )
-// Must downcast from EventStream to concrete type to use in 'for await' loop below
-let concurrentStream = subscriptionResult.stream! as! ConcurrentEventStream
-for try await result in concurrentStream.stream {
+let stream = subscriptionResult.get()
+for try await result in stream {
     print(result)
 }
 ```
@@ -111,18 +105,15 @@ The code above will print the following JSON every 3 seconds:
 { "hello": "world" }
 ```
 
-The example above assumes that your environment has access to Swift Concurrency. If that is not the case, try using
-[GraphQLRxSwift](https://github.com/GraphQLSwift/GraphQLRxSwift)
-
 ## Encoding Results
 
-If you encode a `GraphQLResult` with an ordinary `JSONEncoder`, there are no guarantees that the field order will match the query, 
+If you encode a `GraphQLResult` with an ordinary `JSONEncoder`, there are no guarantees that the field order will match the query,
 violating the [GraphQL spec](https://spec.graphql.org/June2018/#sec-Serialized-Map-Ordering). To preserve this order, `GraphQLResult`
 should be encoded using the `GraphQLJSONEncoder` provided by this package.
 
 ## Support
 
-This package supports Swift versions in [alignment with Swift NIO](https://github.com/apple/swift-nio?tab=readme-ov-file#swift-versions).
+This package aims to support the previous three Swift versions.
 
 For details on upgrading to new major versions, see [MIGRATION](MIGRATION.md).
 
@@ -140,7 +131,7 @@ To format your code, install `swiftformat` and run:
 
 ```bash
 swiftformat .
-```  
+```
 
 Most of this repo mirrors the structure of
 (the canonical GraphQL implementation written in Javascript/Typescript)[https://github.com/graphql/graphql-js]. If there is any feature

README.md

@@ -169,7 +169,7 @@ extension GraphQLError: Hashable {
 
 // MARK: IndexPath
 
-public struct IndexPath: Codable {
+public struct IndexPath: Codable, Sendable {
     public let elements: [IndexPathValue]
 
     public init(_ elements: [IndexPathElement] = []) {
@@ -197,7 +197,7 @@ extension IndexPath: ExpressibleByArrayLiteral {
     }
 }
 
-public enum IndexPathValue: Codable, Equatable {
+public enum IndexPathValue: Codable, Equatable, Sendable {
     case index(Int)
     case key(String)