Initial implementation

.github/workflows/test.yaml

@@ -0,0 +1,19 @@
+name: test
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+jobs:
+  lint:
+    uses: graphqlswift/ci/.github/workflows/lint.yaml@main
+  test:
+    uses: graphqlswift/ci/.github/workflows/test.yaml@main
+    with:
+      include_android: false
+  test-example:
+    uses: graphqlswift/ci/.github/workflows/test.yaml@main
+    with:
+      package_path: "Examples/HelloWorldServer"
+      include_android: false

.gitignore

@@ -6,3 +6,4 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
+/.vscode

Examples/HelloWorldServer/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc
+.vscode

Examples/HelloWorldServer/Package.swift

@@ -0,0 +1,33 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "HelloWorldServer",
+    platforms: [
+        .macOS(.v13),
+    ],
+    dependencies: [
+        .package(name: "graphql-generator", path: "../.."),
+        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "4.0.0"),
+    ],
+    targets: [
+        .target(
+            name: "HelloWorldServer",
+            dependencies: [
+                .product(name: "GraphQL", package: "GraphQL"),
+                .product(name: "GraphQLGeneratorRuntime", package: "graphql-generator"),
+            ],
+            plugins: [
+                .plugin(name: "GraphQLGeneratorPlugin", package: "graphql-generator"),
+            ]
+        ),
+        .testTarget(
+            name: "HelloWorldServerTests",
+            dependencies: [
+                "HelloWorldServer",
+                .product(name: "GraphQL", package: "GraphQL"),
+            ]
+        ),
+    ]
+)

Examples/HelloWorldServer/Sources/HelloWorldServer/Resolvers.swift

@@ -0,0 +1,186 @@
+import Foundation
+import GraphQL
+import GraphQLGeneratorRuntime
+
+// Must be created by user and named `Context`.
+public class Context: @unchecked Sendable {
+    // User can choose structure
+    var users: [String: User]
+    var posts: [String: Post]
+    var onTriggerWatch: () -> Void = {}
+
+    init(
+        users: [String: User],
+        posts: [String: Post]
+    ) {
+        self.users = users
+        self.posts = posts
+    }
+
+    func triggerWatch() {
+        onTriggerWatch()
+    }
+}
+
+// Scalars must be represented by a Swift type of the same name, conforming to the Scalar protocol
+public struct EmailAddress: Scalar {
+    let email: String
+
+    init(email: String) {
+        self.email = email
+    }
+
+    // Codability conformance. Required for usage in InputObject
+    public init(from decoder: any Decoder) throws {
+        email = try decoder.singleValueContainer().decode(String.self)
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        try email.encode(to: encoder)
+    }
+
+    // Scalar conformance. Not necessary, but default methods are very inefficient.
+    public static func serialize(this: Self) throws -> Map {
+        return .string(this.email)
+    }
+
+    public static func parseValue(map: Map) throws -> Map {
+        switch map {
+        case .string:
+            return map
+        default:
+            throw GraphQLError(message: "EmailAddress cannot represent non-string value: \(map)")
+        }
+    }
+
+    public static func parseLiteral(value: any Value) throws -> Map {
+        guard let ast = value as? StringValue else {
+            throw GraphQLError(
+                message: "EmailAddress cannot represent non-string value: \(print(ast: value))",
+                nodes: [value]
+            )
+        }
+        return .string(ast.value)
+    }
+}
+
+// Now create types that conform to the expected protocols
+struct Resolvers: ResolversProtocol {
+    typealias Query = HelloWorldServer.Query
+    typealias Mutation = HelloWorldServer.Mutation
+    typealias Subscription = HelloWorldServer.Subscription
+}
+
+struct User: UserProtocol {
+    // User can choose structure
+    let id: String
+    let name: String
+    let email: String
+    let age: Int?
+    let role: Role?
+
+    // Required implementations
+    func id(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> String {
+        return id
+    }
+
+    func name(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> String {
+        return name
+    }
+
+    func email(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> EmailAddress {
+        return EmailAddress(email: email)
+    }
+
+    func age(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> Int? {
+        return age
+    }
+
+    func role(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> Role? {
+        return role
+    }
+}
+
+struct Contact: ContactProtocol {
+    // User can choose structure
+    let email: String
+
+    // Required implementations
+    func email(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> EmailAddress {
+        return EmailAddress(email: email)
+    }
+}
+
+struct Post: PostProtocol {
+    // User can choose structure
+    let id: String
+    let title: String
+    let content: String
+    let authorId: String
+
+    // Required implementations
+    func id(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> String {
+        return id
+    }
+
+    func title(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> String {
+        return title
+    }
+
+    func content(context _: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> String {
+        return content
+    }
+
+    func author(context: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> any UserProtocol {
+        return context.users[authorId]!
+    }
+}
+
+struct Query: QueryProtocol {
+    // Required implementations
+    static func user(id: String, context: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> (any UserProtocol)? {
+        return context.users[id]
+    }
+
+    static func users(context: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> [any UserProtocol] {
+        return context.users.values.map { $0 as any UserProtocol }
+    }
+
+    static func post(id: String, context: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> (any PostProtocol)? {
+        return context.posts[id]
+    }
+
+    static func posts(limit _: Int?, context: Context, info _: GraphQL.GraphQLResolveInfo) async throws -> [any PostProtocol] {
+        return context.posts.values.map { $0 as any PostProtocol }
+    }
+
+    static func userOrPost(id: String, context: Context, info _: GraphQLResolveInfo) async throws -> (any UserOrPostUnion)? {
+        return context.users[id] ?? context.posts[id]
+    }
+}
+
+struct Mutation: MutationProtocol {
+    // Required implementations
+    static func upsertUser(userInfo: UserInfoInput, context: Context, info _: GraphQLResolveInfo) -> any UserProtocol {
+        let user = User(
+            id: userInfo.id,
+            name: userInfo.name,
+            email: userInfo.email.email,
+            age: userInfo.age,
+            role: userInfo.role
+        )
+        context.users[userInfo.id] = user
+        return user
+    }
+}
+
+struct Subscription: SubscriptionProtocol {
+    // Required implementations
+    static func watchUser(id: String, context: Context, info _: GraphQLResolveInfo) async throws -> AnyAsyncSequence<(any UserProtocol)?> {
+        return AsyncStream<(any UserProtocol)?> { continuation in
+            context.onTriggerWatch = { [weak context] in
+                continuation.yield(context?.users[id])
+            }
+        }.any()
+    }
+}