BREAKING: Converts to Swift Concurrency

MIGRATION.md

@@ -1,6 +1,34 @@
 # 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
+
+### `ConcurrentDispatchFieldExecutionStrategy`
+
+This was changed to `ConcurrentFieldExecutionStrategy`, and takes no parameters.
+
+### 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 a true Swift `Result` type.
+
+### 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.
+
+## 2 to 3
 
 ### TypeReference removal
 
@@ -73,4 +101,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.swift

@@ -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"),
             ]
         ),

README.md

@@ -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