Merge pull request #99 from d-exclaimation/partial-schema-instance

Instance-based PartialSchema

Author: d-exclaimation

README.md

@@ -103,7 +103,12 @@ let api = MessageAPI(
 
 Schemas may also be created in a modular way using `SchemaBuilder`:
 
-```
+<blockquote>
+
+<details open="true">
+<summary>SchemaBuilder API</summary>
+
+```swift
 let builder = SchemaBuilder(Resolver.self, Context.self)
 builder.add(
     Type(Message.self) {
@@ -121,6 +126,66 @@ let api = MessageAPI(
 )
 ``` 
 
+</details>
+<details>
+<summary>PartialSchema implementation</summary>
+
+```swift
+final class ChatSchema: PartialSchema<Resolver, Context> {
+    @TypeDefinitions
+    public override var types: Types {
+        Type(Message.self) {
+            Field("content", at: \.content)
+        }        
+    }
+
+    @FieldDefinitions
+    public override var query: Fields {
+        Field("message", at: Resolver.message)
+    }
+}
+let schema = try SchemaBuilder(Resolver.self, Context.self)
+    .use(partials: [ChatSchema(), ...])
+    .build()
+
+let api = MessageAPI(
+    resolver: Resolver()
+    schema: schema
+)
+``` 
+
+</details>
+
+<details>
+<summary>PartialSchema instance</summary>
+
+```swift
+let chatSchema = PartialSchema<Resolver, Context>(
+    types:  {
+        Type(Message.self) {
+            Field("content", at: \.content)
+        }        
+    },
+    query: {
+        Field("message", at: Resolver.message)
+    }
+)
+let schema = try SchemaBuilder(Resolver.self, Context.self)
+    .use(partials: [chatSchema, ...])
+    .build()
+
+let api = MessageAPI(
+    resolver: Resolver()
+    schema: schema
+)
+``` 
+
+</details>
+
+---
+
+</blockquote>
+
 ⭐️ Notice that `API` allows dependency injection. You could pass mocks of `resolver` and `context` when testing, for example.
 
 #### Querying

Sources/Graphiti/SchemaBuilders/PartialSchema.swift

@@ -13,19 +13,35 @@ open class PartialSchema<Resolver, Context> {
     /// A type that represents a set of operation field definitions
     public typealias Fields = [FieldComponent<Resolver, Context>]
 
+    /// Stored predefined "default" properties for a instance-based declaration
+    private let typedef: Types
+    private let querydef: Fields
+    private let mutationdef: Fields
+    private let subscriptiondef: Fields
+
+    public init(
+        @TypeDefinitions types: () -> Types = { [] },
+        @FieldDefinitions query: () -> Fields = { [] },
+        @FieldDefinitions mutation: () -> Fields = { [] },
+        @FieldDefinitions subscription: () -> Fields = { [] }
+    ) {
+        typedef = types()
+        querydef = query()
+        mutationdef = mutation()
+        subscriptiondef = subscription()
+    }
+
     /// Definitions of types
-    open var types: Types { [] }
+    open var types: Types { typedef }
 
     /// Definitions of query operation fields
-    open var query: Fields { [] }
+    open var query: Fields { querydef }
 
     /// Definitions of mutation operation fields
-    open var mutation: Fields { [] }
+    open var mutation: Fields { mutationdef }
 
     /// Definitions of subscription operation fields
-    open var subscription: Fields { [] }
-
-    public init() {}
+    open var subscription: Fields { subscriptiondef }
 }
 
 public extension Schema {

Tests/GraphitiTests/PartialSchemaTests.swift

@@ -99,6 +99,10 @@ class PartialSchemaTests: XCTestCase {
     func testPartialSchemaWithBuilder() throws {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
 
+        defer {
+            try? group.syncShutdownGracefully()
+        }
+
         let builder = SchemaBuilder(StarWarsResolver.self, StarWarsContext.self)
 
         builder.use(partials: [BaseSchema(), SearchSchema()])
@@ -135,6 +139,10 @@ class PartialSchemaTests: XCTestCase {
     func testPartialSchema() throws {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
 
+        defer {
+            try? group.syncShutdownGracefully()
+        }
+
         /// Double check if static func works and the types are inferred properly
         let schema = try Schema.create(from: [BaseSchema(), SearchSchema()])
 
@@ -168,6 +176,10 @@ class PartialSchemaTests: XCTestCase {
     func testPartialSchemaOutOfOrder() throws {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
 
+        defer {
+            try? group.syncShutdownGracefully()
+        }
+
         /// Double check if ordering of partial schema doesn't matter
         let schema = try Schema.create(from: [SearchSchema(), BaseSchema()])
 
@@ -197,4 +209,131 @@ class PartialSchemaTests: XCTestCase {
             ])
         )
     }
+
+    func testInstancePartialSchema() throws {
+        let baseSchema = PartialSchema<StarWarsResolver, StarWarsContext>(
+            types: {
+                Interface(Character.self) {
+                    Field("id", at: \.id)
+                        .description("The id of the character.")
+                    Field("name", at: \.name)
+                        .description("The name of the character.")
+                    Field("friends", at: \.friends, as: [TypeReference<Character>].self)
+                        .description(
+                            "The friends of the character, or an empty list if they have none."
+                        )
+                    Field("appearsIn", at: \.appearsIn)
+                        .description("Which movies they appear in.")
+                    Field("secretBackstory", at: \.secretBackstory)
+                        .description("All secrets about their past.")
+                }
+
+                Enum(Episode.self) {
+                    Value(.newHope)
+                        .description("Released in 1977.")
+                    Value(.empire)
+                        .description("Released in 1980.")
+                    Value(.jedi)
+                        .description("Released in 1983.")
+                }.description("One of the films in the Star Wars Trilogy.")
+            },
+            query: {
+                Field("hero", at: StarWarsResolver.hero, as: Character.self) {
+                    Argument("episode", at: \.episode)
+                        .description(
+                            "If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode."
+                        )
+                }.description("Returns a hero based on the given episode.")
+            }
+        )
+
+        let searchSchema = PartialSchema<StarWarsResolver, StarWarsContext>(
+            types: {
+                Type(Planet.self) {
+                    Field("id", at: \.id)
+                    Field("name", at: \.name)
+                    Field("diameter", at: \.diameter)
+                    Field("rotationPeriod", at: \.rotationPeriod)
+                    Field("orbitalPeriod", at: \.orbitalPeriod)
+                    Field("residents", at: \.residents)
+                }.description(
+                    "A large mass, planet or planetoid in the Star Wars Universe, at the time of 0 ABY."
+                )
+                Type(Human.self, interfaces: [Character.self]) {
+                    Field("id", at: \.id)
+                    Field("name", at: \.name)
+                    Field("appearsIn", at: \.appearsIn)
+                    Field("homePlanet", at: \.homePlanet)
+                    Field("friends", at: Human.getFriends, as: [Character].self)
+                        .description(
+                            "The friends of the human, or an empty list if they have none."
+                        )
+                    Field("secretBackstory", at: Human.getSecretBackstory)
+                        .description("Where are they from and how they came to be who they are.")
+                }.description("A humanoid creature in the Star Wars universe.")
+                Type(Droid.self, interfaces: [Character.self]) {
+                    Field("id", at: \.id)
+                    Field("name", at: \.name)
+                    Field("appearsIn", at: \.appearsIn)
+                    Field("primaryFunction", at: \.primaryFunction)
+                    Field("friends", at: Droid.getFriends, as: [Character].self)
+                        .description(
+                            "The friends of the droid, or an empty list if they have none."
+                        )
+                    Field("secretBackstory", at: Droid.getSecretBackstory)
+                        .description("Where are they from and how they came to be who they are.")
+                }.description("A mechanical creature in the Star Wars universe.")
+                Union(SearchResult.self, members: Planet.self, Human.self, Droid.self)
+            },
+            query: {
+                Field("human", at: StarWarsResolver.human) {
+                    Argument("id", at: \.id)
+                        .description("Id of the human.")
+                }
+                Field("droid", at: StarWarsResolver.droid) {
+                    Argument("id", at: \.id)
+                        .description("Id of the droid.")
+                }
+                Field("search", at: StarWarsResolver.search, as: [SearchResult].self) {
+                    Argument("query", at: \.query)
+                        .defaultValue("R2-D2")
+                }
+            }
+        )
+
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
+
+        defer {
+            try? group.syncShutdownGracefully()
+        }
+
+        /// Double check if ordering of partial schema doesn't matter
+        let schema = try Schema.create(from: [searchSchema, baseSchema])
+
+        struct PartialSchemaTestAPI: API {
+            let resolver: StarWarsResolver
+            let schema: Schema<StarWarsResolver, StarWarsContext>
+        }
+
+        let api = PartialSchemaTestAPI(resolver: StarWarsResolver(), schema: schema)
+
+        XCTAssertEqual(
+            try api.execute(
+                request: """
+                query {
+                    human(id: "1000") {
+                        name
+                    }
+                }
+                """,
+                context: StarWarsContext(),
+                on: group
+            ).wait(),
+            GraphQLResult(data: [
+                "human": [
+                    "name": "Luke Skywalker",
+                ],
+            ])
+        )
+    }
 }