SchemaGeneratorTests.swift

import GraphQL
@testable import GraphQLGeneratorCore
import Testing

@Suite
struct SchemaGeneratorTests {
    let generator = BuildGraphQLSchemaGenerator()

    @Test func generateSchema() throws {
        let bar = try GraphQLObjectType(
            name: "Bar",
            description: "bar",
            fields: [
                "foo": .init(
                    type: GraphQLString,
                    description: "foo"
                ),
            ]
        )
        let schema = try GraphQLSchema(
            query: .init(
                name: "Query",
                fields: [
                    "foo": .init(
                        type: GraphQLString,
                        description: "foo"
                    ),
                    "bar": .init(
                        type: bar,
                        description: "bar"
                    ),
                ]
            ),
            types: [
                bar,
            ]
        )
        let actual = try generator.generate(schema: schema)
        let expected = #"""
        // Generated by GraphQL Generator
        // DO NOT EDIT - This file is automatically generated

        import Foundation
        import GraphQL
        import GraphQLGeneratorRuntime

        /// Build a GraphQL schema with the provided resolvers
        func buildGraphQLSchema<Resolvers: GraphQLGenerated.Resolvers>(
            resolvers: Resolvers.Type,
            decoder: MapDecoder = .init()
        ) throws -> GraphQLSchema {

            let schema = try GraphQL.buildSchema(source: graphQLRawSDL)

            let bar = schema.typeMap["Bar"] as? GraphQLObjectType
            let barFields = try bar?.fields() ?? [:]
            barFields["foo"]?.resolve = { @Sendable source, args, context, info in
                let parent = try cast(source, to: (any GraphQLGenerated.Bar).self)
                let context = try cast(context, to: GraphQLContext.self)
                return try await parent.foo(context: context, info: info)
            }
            bar?.fields = {
                return barFields
            }

            let query = schema.typeMap["Query"] as? GraphQLObjectType
            let queryFields = try query?.fields() ?? [:]
            queryFields["foo"]?.resolve = { @Sendable source, args, context, info in
                let context = try cast(context, to: GraphQLContext.self)
                return try await Resolvers.Query.foo(context: context, info: info)
            }
            queryFields["bar"]?.resolve = { @Sendable source, args, context, info in
                let context = try cast(context, to: GraphQLContext.self)
                return try await Resolvers.Query.bar(context: context, info: info)
            }
            query?.fields = {
                return queryFields
            }

            return schema
        }

        """#
        #expect(
            actual == expected
        )
    }

    @Test func generateInterfaceType() throws {
        let interfaceType = try GraphQLInterfaceType(
            name: "Node",
            fields: [
                "id": GraphQLField(
                    type: GraphQLNonNull(GraphQLID),
                    description: "The ID of the node"
                ),
            ]
        )

        let result = try generator.generateInterfaceType(for: interfaceType)

        let expected = """

        let node = schema.typeMap["Node"] as? GraphQLObjectType
        let nodeFields = try node?.fields() ?? [:]
        nodeFields["id"]?.resolve = { @Sendable source, args, context, info in
            let parent = try cast(source, to: (any GraphQLGenerated.Node).self)
            let context = try cast(context, to: GraphQLContext.self)
            return try await parent.id(context: context, info: info)
        }
        node?.fields = {
            return nodeFields
        }
        """

        #expect(result == expected)
    }

    @Test func generateObjectTypeParent() throws {
        let objectType = try GraphQLObjectType(
            name: "Book",
            fields: [
                "title": GraphQLField(
                    type: GraphQLNonNull(GraphQLString),
                    description: "The book title"
                ),
                "author": GraphQLField(
                    type: GraphQLString
                ),
            ]
        )

        let result = try generator.generateObjectType(for: objectType, target: .parent)

        let expected = """

        let book = schema.typeMap["Book"] as? GraphQLObjectType
        let bookFields = try book?.fields() ?? [:]
        bookFields["title"]?.resolve = { @Sendable source, args, context, info in
            let parent = try cast(source, to: (any GraphQLGenerated.Book).self)
            let context = try cast(context, to: GraphQLContext.self)
            return try await parent.title(context: context, info: info)
        }
        bookFields["author"]?.resolve = { @Sendable source, args, context, info in
            let parent = try cast(source, to: (any GraphQLGenerated.Book).self)
            let context = try cast(context, to: GraphQLContext.self)
            return try await parent.author(context: context, info: info)
        }
        book?.fields = {
            return bookFields
        }
        """

        #expect(result == expected)
    }

    @Test func generateObjectTypeForQuery() throws {
        let queryType = try GraphQLObjectType(
            name: "Query",
            description: "The query root",
            fields: [
                "user": GraphQLField(
                    type: GraphQLString,
                    description: "Get a user"
                ),
            ]
        )

        let result = try generator.generateObjectType(for: queryType, target: .query)

        let expected = """

        let query = schema.typeMap["Query"] as? GraphQLObjectType
        let queryFields = try query?.fields() ?? [:]
        queryFields["user"]?.resolve = { @Sendable source, args, context, info in
            let context = try cast(context, to: GraphQLContext.self)
            return try await Resolvers.Query.user(context: context, info: info)
        }
        query?.fields = {
            return queryFields
        }
        """

        #expect(result == expected)
    }

    @Test func generateObjectTypeForMutation() throws {
        let mutationType = try GraphQLObjectType(
            name: "Mutation",
            fields: [
                "createUser": GraphQLField(
                    type: GraphQLString,
                    description: "Create a user"
                ),
            ]
        )

        let result = try generator.generateObjectType(for: mutationType, target: .mutation)

        let expected = """

        let mutation = schema.typeMap["Mutation"] as? GraphQLObjectType
        let mutationFields = try mutation?.fields() ?? [:]
        mutationFields["createUser"]?.resolve = { @Sendable source, args, context, info in
            let context = try cast(context, to: GraphQLContext.self)
            return try await Resolvers.Mutation.createUser(context: context, info: info)
        }
        mutation?.fields = {
            return mutationFields
        }
        """

        #expect(result == expected)
    }

    @Test func generateObjectTypeForSubscription() throws {
        let subscriptionType = try GraphQLObjectType(
            name: "Subscription",
            fields: [
                "userUpdated": GraphQLField(
                    type: GraphQLString,
                    description: "Subscribe to user updates"
                ),
            ]
        )

        let result = try generator.generateObjectType(for: subscriptionType, target: .subscription)

        let expected = """

        let subscription = schema.typeMap["Subscription"] as? GraphQLObjectType
        let subscriptionFields = try subscription?.fields() ?? [:]
        subscriptionFields["userUpdated"]?.resolve = { @Sendable source, _, _, _ in
            return source
        }
        subscriptionFields["userUpdated"]?.subscribe = { @Sendable source, args, context, info in
            let context = try cast(context, to: GraphQLContext.self)
            return try await Resolvers.Subscription.userUpdated(context: context, info: info)
        }
        subscription?.fields = {
            return subscriptionFields
        }
        """

        #expect(result == expected)
    }

    // MARK: - Resolver Callback Tests

    @Test func generateResolverCallbackForParent() throws {
        let scalar = try GraphQLScalarType(name: "Scalar")
        let field = GraphQLField(
            type: GraphQLString,
            args: [
                "filter": GraphQLArgument(type: GraphQLString),
                "scalar": GraphQLArgument(type: GraphQLNonNull(scalar)),
            ]
        )

        let objectType = try GraphQLObjectType(name: "User")

        let result = try generator.generateResolverCallback(
            variableName: "queryFields",
            fieldName: "posts",
            field: field,
            target: .parent,
            parentType: objectType
        )

        let expected = """
        queryFields["posts"]?.resolve = { @Sendable source, args, context, info in
            let parent = try cast(source, to: (any GraphQLGenerated.User).self)
            let filter = args["filter"] != .undefined ? try decoder.decode((String?).self, from: args["filter"]) : nil
            let scalar = try decoder.decode((GraphQLScalars.Scalar).self, from: args["scalar"])
            let context = try cast(context, to: GraphQLContext.self)
            return try await parent.posts(filter: filter, scalar: scalar, context: context, info: info)
        }
        """

        #expect(result == expected)
    }

    @Test func generateResolverCallbackForQuery() throws {
        let field = GraphQLField(
            type: GraphQLString,
            args: [
                "id": GraphQLArgument(type: GraphQLNonNull(GraphQLID)),
            ]
        )

        let queryType = try GraphQLObjectType(name: "Query")

        let result = try generator.generateResolverCallback(
            variableName: "queryFields",
            fieldName: "user",
            field: field,
            target: .query,
            parentType: queryType
        )

        let expected = """
        queryFields["user"]?.resolve = { @Sendable source, args, context, info in
            let id = try decoder.decode((String).self, from: args["id"])
            let context = try cast(context, to: GraphQLContext.self)
            return try await Resolvers.Query.user(id: id, context: context, info: info)
        }
        """

        #expect(result == expected)
    }

    @Test func generateResolverCallbackForSubscription() throws {
        let field = GraphQLField(
            type: GraphQLString
        )

        let subscriptionType = try GraphQLObjectType(name: "Subscription")

        let result = try generator.generateResolverCallback(
            variableName: "subscriptionFields",
            fieldName: "messageAdded",
            field: field,
            target: .subscription,
            parentType: subscriptionType
        )

        let expected = """
        subscriptionFields["messageAdded"]?.resolve = { @Sendable source, _, _, _ in
            return source
        }
        subscriptionFields["messageAdded"]?.subscribe = { @Sendable source, args, context, info in
            let context = try cast(context, to: GraphQLContext.self)
            return try await Resolvers.Subscription.messageAdded(context: context, info: info)
        }
        """

        #expect(result == expected)
    }
}