Merge pull request #87 from NeedleInAJayStack/feature/schemaBuilder

NeedleInAJayStack · web-flow · commit e972e2e539b5 · 2023-01-26T14:22:08.000-07:00
Adds a SchemaBuilder type for modular schema creation
diff --git a/README.md b/README.md
@@ -85,44 +85,59 @@ Now we can finally define the GraphQL API with its schema.
 struct MessageAPI : API {
     let resolver: Resolver
     let schema: Schema<Resolver, Context>
-    
-    init(resolver: Resolver) throws {
-        self.resolver = resolver
-
-        self.schema = try Schema<Resolver, Context> {
-            Type(Message.self) {
-                Field("content", at: \.content)
-            }
-
-            Query {
-                Field("message", at: Resolver.message)
-            }
+}
+        
+let api = MessageAPI(
+    resolver: Resolver()
+    schema: try! Schema<Resolver, Context> {
+        Type(Message.self) {
+            Field("content", at: \.content)
+        }
+
+        Query {
+            Field("message", at: Resolver.message)
         }
     }
-}
+)
 ```
 
+Schemas may also be created in a modular way using `SchemaBuilder`:
+
+```
+let builder = SchemaBuilder(Resolver.self, Context.self)
+builder.add(
+    Type(Message.self) {
+        Field("content", at: \.content)
+    }
+)
+builder.query.add(
+    Field("message", at: Resolver.message)
+)
+let schema = try builder.build()
+
+let api = MessageAPI(
+    resolver: Resolver()
+    schema: schema
+)
+``` 
+
 ⭐️ Notice that `API` allows dependency injection. You could pass mocks of `resolver` and `context` when testing, for example.
 
 #### Querying
 
-To query the schema we need to instantiate the api and pass in an EventLoopGroup to feed the execute function alongside the query itself.
+To query the schema we need to pass in a NIO EventLoopGroup to feed the execute function alongside the query itself.
 
 ```swift
 import NIO
 
-let resolver = Resolver()
-let context = Context()
-let api = try MessageAPI(resolver: resolver)
 let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
-        
 defer {
     try? group.syncShutdownGracefully()
 }
 
 api.execute(
     request: "{ message { content } }",
-    context: context,
+    context: Context(),
     on: group
 ).whenSuccess { result in
     print(result)
diff --git a/Sources/Graphiti/Component/TypeComponent.swift b/Sources/Graphiti/Component/TypeComponent.swift
@@ -0,0 +1,2 @@
+/// Type-based components (`Enum`, `Input`, `Interface`, `Scalar`, `Type`, `Union`) subclass from this class
+open class TypeComponent<Resolver, Context>: Component<Resolver, Context> {}
diff --git a/Sources/Graphiti/Component/TypeComponentBuilder.swift b/Sources/Graphiti/Component/TypeComponentBuilder.swift
@@ -0,0 +1,14 @@
+@resultBuilder
+public enum TypeComponentBuilder<Resolver, Context> {
+    public static func buildExpression(
+        _ component: TypeComponent<Resolver, Context>
+    ) -> TypeComponent<Resolver, Context> {
+        component
+    }
+
+    public static func buildBlock(
+        _ components: TypeComponent<Resolver, Context>...
+    ) -> [TypeComponent<Resolver, Context>] {
+        components
+    }
+}
diff --git a/Sources/Graphiti/Enum/Enum.swift b/Sources/Graphiti/Enum/Enum.swift
@@ -4,7 +4,7 @@ public final class Enum<
     Resolver,
     Context,
     EnumType: Encodable & RawRepresentable
->: Component<
+>: TypeComponent<
     Resolver,
     Context
 > where EnumType.RawValue == String {
diff --git a/Sources/Graphiti/Input/Input.swift b/Sources/Graphiti/Input/Input.swift
@@ -4,7 +4,7 @@ public final class Input<
     Resolver,
     Context,
     InputObjectType: Decodable
->: Component<
+>: TypeComponent<
     Resolver,
     Context
 > {
diff --git a/Sources/Graphiti/Interface/Interface.swift b/Sources/Graphiti/Interface/Interface.swift
@@ -1,6 +1,9 @@
 import GraphQL
 
-public final class Interface<Resolver, Context, InterfaceType>: Component<Resolver, Context> {
+public final class Interface<Resolver, Context, InterfaceType>: TypeComponent<
+    Resolver,
+    Context
+> {
     let fields: [FieldComponent<InterfaceType, Context>]
 
     override func update(typeProvider: SchemaTypeProvider, coders: Coders) throws {
diff --git a/Sources/Graphiti/Mutation/Mutation.swift b/Sources/Graphiti/Mutation/Mutation.swift
@@ -27,7 +27,7 @@ public final class Mutation<Resolver, Context>: Component<Resolver, Context> {
         return map
     }
 
-    private init(
+    init(
         name: String,
         fields: [FieldComponent<Resolver, Context>]
     ) {
diff --git a/Sources/Graphiti/Query/Query.swift b/Sources/Graphiti/Query/Query.swift
@@ -27,7 +27,7 @@ public final class Query<Resolver, Context>: Component<Resolver, Context> {
         return map
     }
 
-    private init(
+    init(
         name: String,
         fields: [FieldComponent<Resolver, Context>]
     ) {
diff --git a/Sources/Graphiti/Scalar/Scalar.swift b/Sources/Graphiti/Scalar/Scalar.swift
@@ -6,7 +6,7 @@ import OrderedCollections
 /// It is **highly** recommended that you do not subclass this type.
 /// Instead, modify the encoding/decoding behavior through the `MapEncoder`/`MapDecoder` options available through
 /// `Coders` or a custom encoding/decoding on the `ScalarType` itself.
-open class Scalar<Resolver, Context, ScalarType: Codable>: Component<Resolver, Context> {
+open class Scalar<Resolver, Context, ScalarType: Codable>: TypeComponent<Resolver, Context> {
     // TODO: Change this no longer be an open class
 
     override func update(typeProvider: SchemaTypeProvider, coders: Coders) throws {
diff --git a/Sources/Graphiti/Schema/Schema.swift b/Sources/Graphiti/Schema/Schema.swift
@@ -4,7 +4,7 @@ import NIO
 public final class Schema<Resolver, Context> {
     public let schema: GraphQLSchema
 
-    private init(
+    init(
         coders: Coders,
         components: [Component<Resolver, Context>]
     ) throws {
diff --git a/Sources/Graphiti/SchemaBuilders/SchemaBuilder.swift b/Sources/Graphiti/SchemaBuilders/SchemaBuilder.swift
@@ -0,0 +1,130 @@
+/// A builder that allows modular creation of GraphQL schemas. You may independently components or query, mutation, or subscription fields.
+/// When ready to build and use the schema, run `build`
+public final class SchemaBuilder<Resolver, Context> {
+    private var coders: Coders
+    private var typeComponents: [TypeComponent<Resolver, Context>]
+    private var queryName: String
+    private var queryFields: [FieldComponent<Resolver, Context>]
+    private var mutationName: String
+    private var mutationFields: [FieldComponent<Resolver, Context>]
+    private var subscriptionName: String
+    private var subscriptionFields: [FieldComponent<Resolver, Context>]
+
+    public init(
+        _ resolverType: Resolver.Type,
+        _ contextType: Context.Type
+    ) {
+        coders = Coders()
+        typeComponents = []
+        
+        queryName = "Query"
+        queryFields = []
+        mutationName = "Mutation"
+        mutationFields = []
+        subscriptionName = "Subscription"
+        subscriptionFields = []
+    }
+
+    @discardableResult
+    /// Allows for setting API encoders and decoders with customized settings.
+    /// - Parameter newCoders: The new coders to use
+    /// - Returns: This object for method chaining
+    public func setCoders(to newCoders: Coders) -> Self {
+        coders = newCoders
+        return self
+    }
+    
+    @discardableResult
+    public func setQueryName(to name: String) -> Self {
+        queryName = name
+        return self
+    }
+    
+    @discardableResult
+    public func setMutationName(to name: String) -> Self {
+        mutationName = name
+        return self
+    }
+    
+    @discardableResult
+    public func setSubscriptionName(to name: String) -> Self {
+        subscriptionName = name
+        return self
+    }
+
+    @discardableResult
+    /// Adds multiple query operation definitions to the schema.
+    /// - Parameter component: The query operations to add
+    /// - Returns: This object for method chaining
+    public func add(
+        @TypeComponentBuilder<Resolver, Context> _ components: () -> [TypeComponent<Resolver, Context>]
+    ) -> Self {
+        for component in components() {
+            typeComponents.append(component)
+        }
+        return self
+    }
+    
+    @discardableResult
+    /// Adds multiple query operation definitions to the schema.
+    /// - Parameter component: The query operations to add
+    /// - Returns: This object for method chaining
+    public func addQuery(
+        @FieldComponentBuilder<Resolver, Context> _ fields: () -> [FieldComponent<Resolver, Context>]
+    ) -> Self {
+        for field in fields() {
+            self.queryFields.append(field)
+        }
+        return self
+    }
+    
+    @discardableResult
+    /// Adds multiple mutation operation definitions to the schema.
+    /// - Parameter component: The query operations to add
+    /// - Returns: This object for method chaining
+    public func addMutation(
+        @FieldComponentBuilder<Resolver, Context> _ fields: () -> [FieldComponent<Resolver, Context>]
+    ) -> Self {
+        for field in fields() {
+            self.mutationFields.append(field)
+        }
+        return self
+    }
+    
+    @discardableResult
+    /// Adds multiple subscription operation definitions to the schema.
+    /// - Parameter component: The query operations to add
+    /// - Returns: This object for method chaining
+    public func addSubscription(
+        @FieldComponentBuilder<Resolver, Context> _ fields: () -> [FieldComponent<Resolver, Context>]
+    ) -> Self {
+        for field in fields() {
+            self.subscriptionFields.append(field)
+        }
+        return self
+    }
+
+    /// Create and return the queryable GraphQL schema
+    public func build() throws -> Schema<Resolver, Context> {
+        var components = typeComponents.map { topLevelComponent in
+            topLevelComponent as Component<Resolver, Context>
+        }
+
+        if !queryFields.isEmpty {
+            let query = Query(name: queryName, fields: queryFields)
+            components.append(query)
+        }
+
+        if !mutationFields.isEmpty {
+            let mutation = Mutation(name: mutationName, fields: mutationFields)
+            components.append(mutation)
+        }
+
+        if !subscriptionFields.isEmpty {
+            let subscription = Subscription(name: subscriptionName, fields: subscriptionFields)
+            components.append(subscription)
+        }
+
+        return try Schema(coders: coders, components: components)
+    }
+}
diff --git a/Sources/Graphiti/Subscription/Subscription.swift b/Sources/Graphiti/Subscription/Subscription.swift
@@ -27,7 +27,7 @@ public final class Subscription<Resolver, Context>: Component<Resolver, Context>
         return map
     }
 
-    private init(
+    init(
         name: String,
         fields: [FieldComponent<Resolver, Context>]
     ) {
diff --git a/Sources/Graphiti/Type/Type.swift b/Sources/Graphiti/Type/Type.swift
@@ -1,6 +1,9 @@
 import GraphQL
 
-public final class Type<Resolver, Context, ObjectType: Encodable>: Component<Resolver, Context> {
+public final class Type<Resolver, Context, ObjectType: Encodable>: TypeComponent<
+    Resolver,
+    Context
+> {
     let interfaces: [Any.Type]
     let fields: [FieldComponent<ObjectType, Context>]
 
@@ -80,4 +83,20 @@ public extension Type {
             fields: fields()
         )
     }
+
+    convenience init(
+        resolver _: Resolver.Type,
+        context _: Context.Type,
+        _ type: ObjectType.Type,
+        as name: String? = nil,
+        interfaces: [Any.Type] = [],
+        fields: [FieldComponent<ObjectType, Context>]
+    ) {
+        self.init(
+            type: type,
+            name: name,
+            interfaces: interfaces,
+            fields: fields
+        )
+    }
 }
diff --git a/Sources/Graphiti/Union/Union.swift b/Sources/Graphiti/Union/Union.swift
@@ -1,6 +1,6 @@
 import GraphQL
 
-public final class Union<Resolver, Context, UnionType>: Component<Resolver, Context> {
+public final class Union<Resolver, Context, UnionType>: TypeComponent<Resolver, Context> {
     private let members: [Any.Type]
 
     override func update(typeProvider: SchemaTypeProvider, coders _: Coders) throws {
diff --git a/Tests/GraphitiTests/SchemaBuilderTests.swift b/Tests/GraphitiTests/SchemaBuilderTests.swift

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+/// Type-based components (`Enum`, `Input`, `Interface`, `Scalar`, `Type`, `Union`) subclass from this class
	`2`	`+open class TypeComponent<Resolver, Context>: Component<Resolver, Context> {}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public final class Mutation<Resolver, Context>: Component<Resolver, Context> {`
`27`	`27`	`return map`
`28`	`28`	`}`
`29`	`29`
`30`		`- private init(`
	`30`	`+ init(`
`31`	`31`	`name: String,`
`32`	`32`	`fields: [FieldComponent<Resolver, Context>]`
`33`	`33`	`) {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public final class Query<Resolver, Context>: Component<Resolver, Context> {`
`27`	`27`	`return map`
`28`	`28`	`}`
`29`	`29`
`30`		`- private init(`
	`30`	`+ init(`
`31`	`31`	`name: String,`
`32`	`32`	`fields: [FieldComponent<Resolver, Context>]`
`33`	`33`	`) {`