feat!: Scalars are namespaced inside GraphQLScalars

This will prevent type name collisions. In some common schemas, we were already hitting name collisions between custom scalars and Foundation types (Like `Date` and `URL`).

Author: NeedleInAJayStack

Examples/HelloWorldServer/Sources/HelloWorldServer/Resolvers.swift

@@ -22,45 +22,48 @@ class GraphQLContext: @unchecked Sendable {
     }
 }
 
-// Scalars must be represented by a Swift type of the same name, conforming to the Scalar protocol
-struct EmailAddress: GraphQLScalar {
-    let email: String
-
-    init(email: String) {
-        self.email = email
-    }
+// Scalars must be represented by a Swift type of the same name in the GraphQLScalars namespace, conforming to
+// the GraphQLScalar protocol
+extension GraphQLScalars {
+    struct EmailAddress: GraphQLScalar {
+        let email: String
+
+        init(email: String) {
+            self.email = email
+        }
 
-    // Codability conformance. Required for usage in InputObject
-    init(from decoder: any Decoder) throws {
-        email = try decoder.singleValueContainer().decode(String.self)
-    }
+        // Codability conformance. Required for usage in InputObject
+        init(from decoder: any Decoder) throws {
+            email = try decoder.singleValueContainer().decode(String.self)
+        }
 
-    func encode(to encoder: any Encoder) throws {
-        try email.encode(to: encoder)
-    }
+        func encode(to encoder: any Encoder) throws {
+            try email.encode(to: encoder)
+        }
 
-    // Scalar conformance. Not necessary, but default methods are very inefficient.
-    static func serialize(this: Self) throws -> Map {
-        return .string(this.email)
-    }
+        // Scalar conformance. Not necessary, but default methods are very inefficient.
+        static func serialize(this: Self) throws -> Map {
+            return .string(this.email)
+        }
 
-    static func parseValue(map: Map) throws -> Map {
-        switch map {
-        case .string:
-            return map
-        default:
-            throw GraphQLError(message: "EmailAddress cannot represent non-string value: \(map)")
+        static func parseValue(map: Map) throws -> Map {
+            switch map {
+            case .string:
+                return map
+            default:
+                throw GraphQLError(message: "EmailAddress cannot represent non-string value: \(map)")
+            }
         }
-    }
 
-    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]
-            )
+        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)
         }
-        return .string(ast.value)
     }
 }
 
@@ -88,8 +91,8 @@ struct User: GraphQLGenerated.User {
         return name
     }
 
-    func email(context _: GraphQLContext, info _: GraphQL.GraphQLResolveInfo) async throws -> EmailAddress {
-        return EmailAddress(email: email)
+    func email(context _: GraphQLContext, info _: GraphQL.GraphQLResolveInfo) async throws -> GraphQLScalars.EmailAddress {
+        return .init(email: email)
     }
 
     func age(context _: GraphQLContext, info _: GraphQL.GraphQLResolveInfo) async throws -> Int? {
@@ -106,8 +109,8 @@ struct Contact: GraphQLGenerated.Contact {
     let email: String
 
     // Required implementations
-    func email(context _: GraphQLContext, info _: GraphQL.GraphQLResolveInfo) async throws -> EmailAddress {
-        return EmailAddress(email: email)
+    func email(context _: GraphQLContext, info _: GraphQL.GraphQLResolveInfo) async throws -> GraphQLScalars.EmailAddress {
+        return .init(email: email)
     }
 }
 

README.md

@@ -68,11 +68,11 @@ actor GraphQLContext {
 }
 ```
 
-Create any scalar types (with names matching GraphQL), and conform them to `GraphQLScalar`. See the `Scalars` usage section below for details.
+If your schema has any custom scalar types, you must create them manually in the `GraphQLScalars` namespace. See the `Scalars` usage section below for details.
 
 Create a resolvers struct with the required typealiases:
 ```swift
-struct Resolvers: ResolversProtocol {
+struct Resolvers: GraphQLGenerated.Resolvers {
     typealias Query = ExamplePackage.Query
     typealias Mutation = ExamplePackage.Mutation
     typealias Subscription = ExamplePackage.Subscription
@@ -84,7 +84,7 @@ As you build the `Query`, `Mutation`, and `Subscription` types and their resolut
 ```swift
 struct Query: GraphQLGenerated.Query {
     // This is required by `GraphQLGenerated.Query`, and used by GraphQL query resolution.
-    static func user(context: GraphQLContext, info: GraphQLResolveInfo) async throws -> (any UserProtocol)? {
+    static func user(context: GraphQLContext, info: GraphQLResolveInfo) async throws -> (any GraphQLGenerated.User)? {
         // You can implement resolution logic however you like.
         return context.user
     }
@@ -99,9 +99,9 @@ struct User: GraphQLGenerated.User {
     func name(context: GraphQLContext, info: GraphQLResolveInfo) async throws -> String {
         return name
     }
-    func email(context: GraphQLContext, info: GraphQLResolveInfo) async throws -> EmailAddress {
+    func email(context: GraphQLContext, info: GraphQLResolveInfo) async throws -> GraphQLScalars.EmailAddress {
         // You can implement resolution logic however you like.
-        return EmailAddress(email: self.email)
+        return .init(email: self.email)
     }
 }
 ```
@@ -123,7 +123,7 @@ print(result)
 All generated types other than `GraphQLContext` and scalar types are namespaced inside of `GraphQLGenerated` to minimize polluting the inheriting package's type namespace.
 
 ### Root Types
-Root types (Query, Mutation, and Subscription) are modeled as Swift protocols with static method requirements for each field. The user must implement these types and provide them to the `buildGraphQLSchema` function.
+Root types (Query, Mutation, and Subscription) are modeled as Swift protocols with static method requirements for each field. The user must implement these types and provide them to the `buildGraphQLSchema` function via the `Resolvers` typealiases.
 
 ### Object Types
 Object types are modeled as Swift protocols with instance method requirements for each field. This is to enable maximum implementation flexibility. Internally, GraphQL passes result objects directly through to subsequent resolvers. By only specifying the interface, we allow the backing types to be incredibly dynamic - they can be simple codable structs or complex stateful actors, reference or values types, or any other type configuration.
@@ -166,52 +166,52 @@ Interfaces are modeled as a protocol with required methods for each relevant fie
 Union types are modeled as a marker protocol, with no required properties or functions. Related objects are marked as requiring conformance to the union protocol.
 
 ### Input Object Types
-Input object types are modeled as a deterministic Codable struct with the declared fields. If more complex objects must be created from the codable struct, this can be done in the resolver itself, since input objects only relevant for their associated resolver (they are not passed to downstream resolvers).
+Input object types are modeled as a deterministic Codable struct with the declared fields. If more complex objects must be created from the codable struct, this can be done in the resolver itself, since input objects are only relevant for their associated resolver (they are not passed to downstream resolvers).
 
 ### Enum Types
 Enum types are modeled as a deterministic String enum with values matching the declared fields and associated representations. If you need different values or more complex implementations, simply convert to/from a different representation inside your resolvers.
 
 ### Scalar Types
-Scalar types are not modeled by the generator. They are simply referenced using the Scalar's name, and you are expected to implement the required type. Since GraphQL uses a different serialization system than Swift, you must conform the type to Swift's `Codable` and GraphQL's `GraphQLScalar`, and have them agree on a representation.
-
-Below is an example that represents a scalar struct as a raw String:
+Scalar types are not modeled by the generator. They are simply referenced as `GraphQLScalars.<name>`, and you are expected to implement the required type, and conform it to `GraphQLScalar`. Since GraphQL uses a different serialization system than Swift, you should be sure that the type's conformance to Swift's `Codable` and GraphQL's `GraphQLScalar` agree on a representation. Below is an example that represents a scalar struct as a raw String:
 
 ```swift
-struct EmailAddress: GraphQLScalar {
-    let email: String
+extension GraphQLScalars {
+    struct EmailAddress: GraphQLScalar {
+        let email: String
 
-    init(email: String) {
-        self.email = email
-    }
+        init(email: String) {
+            self.email = email
+        }
 
-    // Codability conformance. Represent simply as `email` string.
-    init(from decoder: any Decoder) throws {
-        self.email = try decoder.singleValueContainer().decode(String.self)
-    }
-    func encode(to encoder: any Encoder) throws {
-        try self.email.encode(to: encoder)
-    }
+        // Codability conformance. Represent simply as `email` string.
+        init(from decoder: any Decoder) throws {
+            self.email = try decoder.singleValueContainer().decode(String.self)
+        }
+        func encode(to encoder: any Encoder) throws {
+            try self.email.encode(to: encoder)
+        }
 
-    // Scalar conformance. Parse & serialize simply as `email` string.
-    static func serialize(this: Self) throws -> Map {
-        return .string(this.email)
-    }
-    static func parseValue(map: Map) throws -> Map {
-        switch map {
-        case .string:
-            return map
-        default:
-            throw GraphQLError(message: "EmailAddress cannot represent non-string value: \(map)")
+        // Scalar conformance. Parse & serialize simply as `email` string.
+        static func serialize(this: Self) throws -> Map {
+            return .string(this.email)
         }
-    }
-    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]
-            )
+        static func parseValue(map: Map) throws -> Map {
+            switch map {
+            case .string:
+                return map
+            default:
+                throw GraphQLError(message: "EmailAddress cannot represent non-string value: \(map)")
+            }
+        }
+        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)
         }
-        return .string(ast.value)
     }
 }
 ```

Sources/GraphQLGeneratorCore/Generator/GraphQLTypesGenerator.swift

@@ -14,10 +14,7 @@ package struct GraphQLTypesGenerator {
         import GraphQL
         import GraphQLGeneratorRuntime
 
-        """
-
-        // Generate Resolvers protocol
-        output += """
+        enum GraphQLScalars { }
 
         enum GraphQLGenerated {
             protocol Resolvers: Sendable {

Sources/GraphQLGeneratorCore/Utilities/swiftTypeName.swift

@@ -37,8 +37,9 @@ func swiftTypeReference(for type: GraphQLType, includeNamespace: Bool, nameGener
         if namedType is GraphQLUnionType || namedType is GraphQLInterfaceType || namedType is GraphQLObjectType {
             // These are all interfaces, so we must wrap them in 'any' and parentheses for optionals.
             return "(any \(baseName))?"
-        } else if namedType is GraphQLScalarType {
-            let swiftScalar = mapScalarType(namedType.name, includeNamespace: includeNamespace, nameGenerator: nameGenerator)
+        }
+        if let scalarType = namedType as? GraphQLScalarType {
+            let swiftScalar = mapScalarType(scalarType, includeNamespace: includeNamespace, nameGenerator: nameGenerator)
             return "\(swiftScalar)?"
         }
         return "\(baseName)?"
@@ -80,20 +81,17 @@ func swiftTypeDeclaration(for type: GraphQLType, includeNamespace: Bool, nameGen
 ///   - graphQLType: The GraphQL Type to generate a reference to
 ///   - includeNamespace: Whether to include the `GraphQLGenerated` type namespace in the result
 ///   - nameGenerator: The name generator
-func mapScalarType(_ graphQLType: String, includeNamespace: Bool, nameGenerator: SafeNameGenerator) -> String {
-    switch graphQLType {
+func mapScalarType(_ type: GraphQLScalarType, includeNamespace: Bool, nameGenerator: SafeNameGenerator) -> String {
+    switch type.name {
     case "ID": return "String"
     case "String": return "String"
     case "Int": return "Int"
     case "Float": return "Double"
     case "Boolean": return "Bool"
     default:
         // For custom scalars, use safe name generator
-        var name = nameGenerator.swiftTypeName(for: graphQLType)
-        if includeNamespace {
-            name = "GraphQLGenerated.\(name)"
-        }
-        return name
+        let baseName = nameGenerator.swiftTypeName(for: type.name)
+        return "GraphQLScalars.\(baseName)"
     }
 }
 

Tests/GraphQLGeneratorCoreTests/SchemaGeneratorTests.swift

@@ -249,10 +249,12 @@ struct SchemaGeneratorTests {
     // 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)),
             ]
         )
 
@@ -270,8 +272,9 @@ struct SchemaGeneratorTests {
         fields["posts"]?.resolve = { 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, context: context, info: info)
+            return try await parent.posts(filter: filter, scalar: scalar, context: context, info: info)
         }
         """
 

Tests/GraphQLGeneratorCoreTests/TypeGeneratorTests.swift

@@ -108,6 +108,35 @@ struct TypeGeneratorTests {
         #expect(result == expected)
     }
 
+    @Test func generateInputStructWithCustomScalar() throws {
+        let phoneNumber: GraphQLScalarType = try GraphQLScalarType(
+            name: "PhoneNumber"
+        )
+        let personInput = try GraphQLInputObjectType(
+            name: "PersonInput"
+        )
+        personInput.fields = {
+            [
+                "cellPhone": InputObjectField(type: GraphQLNonNull(phoneNumber)),
+                "homePhone": InputObjectField(type: phoneNumber),
+                "familyPhones": InputObjectField(type: GraphQLList(phoneNumber)),
+            ]
+        }
+
+        let result = try generator.generateInputStruct(for: personInput)
+
+        let expected = """
+
+        struct PersonInput: Codable, Sendable {
+            let cellPhone: GraphQLScalars.PhoneNumber
+            let homePhone: GraphQLScalars.PhoneNumber?
+            let familyPhones: [GraphQLScalars.PhoneNumber]?
+        }
+        """
+
+        #expect(result == expected)
+    }
+
     @Test func generateInterfaceProtocol() async throws {
         let interfaceA = try GraphQLInterfaceType(
             name: "A",
@@ -160,6 +189,7 @@ struct TypeGeneratorTests {
             name: "A",
             description: "A"
         )
+        let scalar = try GraphQLScalarType(name: "Scalar")
         let typeFoo = try GraphQLObjectType(
             name: "Foo",
             description: "Foo",
@@ -181,6 +211,15 @@ struct TypeGeneratorTests {
                         ),
                     ]
                 ),
+                "baz": .init(
+                    type: scalar,
+                    description: "baz",
+                    args: [
+                        "baz": .init(
+                            type: GraphQLNonNull(scalar)
+                        )
+                    ]
+                ),
             ],
             interfaces: [interfaceA]
         )
@@ -201,6 +240,9 @@ struct TypeGeneratorTests {
                 /// bar
                 func bar(foo: String, bar: String?, context: GraphQLContext, info: GraphQLResolveInfo) async throws -> String?
 
+                /// baz
+                func baz(baz: GraphQLScalars.Scalar, context: GraphQLContext, info: GraphQLResolveInfo) async throws -> GraphQLScalars.Scalar?
+
             }
             """
         )