Add support for many-to-many relationships (@Siblings) in Fluent

Author: alexsteinerde

README.md

@@ -63,23 +63,44 @@ enum TodoState: String, CaseIterable {
 Enum(TodoState.self),
 ```
 
-#### `Parent` and `Children`
-Vapor has the functionality to fetch an objects parent and children automatically with `@Parent` and @`Children` types. To integrate this into GraphQL, GraphQLKit provides extensions to the `Field` type that lets you use the parent or children property as a keypath. The fetching of those related objects is then done automatically.
+#### `Parent`,  `Children` and `Siblings`
+Vapor has the functionality to fetch an objects parent, children or siblings automatically with `@Parent`, `@Children` and `@Siblings` types. To integrate this into GraphQL, GraphQLKit provides extensions to the `Field` type that lets you use the parent, children or siblings property as a keypath. Fetching of those related objects is then done automatically.
 
 > :warning: Loading related objects in GraphQL has the [**N+1** problem](https://itnext.io/what-is-the-n-1-problem-in-graphql-dd4921cb3c1a). A solution would be to build a DataLoader package for Swift. But this hasn't been done yet.
 
 ```swift
-final class User {
+final class User: Model {
     ...
-    var userId: UUID
-    @Parent(key: "userId") var user: User
+    
+    @Children(for: \.$user)
+    var todos: [Todo]
+    
+    ...
+}
+
+final class Todo: Model {
+    ...
+    
+    @Parent(key: "user_id")
+    var user: User
+    
+    @Siblings(through: TodoTag.self, from: \.$todo, to: \.$tag)
+    public var tags: [Tag]
+    
     ...
 }
 ```
 
 ```swift
-// Schema type: 
-Field(.user, with: \.user),
+// Schema types
+Type(User.self) {
+    Field("todos", with: \.$todos)
+}
+
+Type(Todo.self) {
+    Field("user", with: \.$user)
+    Field("tags", with: \.$tags)
+}
 ```
 
 ### Register the schema on the application

Sources/GraphQLKit/Graphiti+Fluent.swift

@@ -2,28 +2,59 @@ import Graphiti
 import Vapor
 import Fluent
 
+// Child Relationship
 extension Graphiti.Field where Arguments == NoArguments, Context == Request, ObjectType: Model {
+    
+    /// Creates a GraphQL field for a one-to-many  relationship for Fluent
+    /// - Parameters:
+    ///   - name: Filed name
+    ///   - keyPath: KeyPath to the @Children property
     public convenience init<ChildType: Model>(
         _ name: FieldKey,
         with keyPath: KeyPath<ObjectType, ChildrenProperty<ObjectType, ChildType>>
     ) where FieldType == [TypeReference<ChildType>] {
         self.init(name.description, at: { (type) -> (Request, NoArguments, EventLoopGroup) throws -> EventLoopFuture<[ChildType]> in
             return { (context: Request, arguments: NoArguments, eventLoop: EventLoopGroup) in
-                return type[keyPath: keyPath].query(on: context.db).all()
+                return type[keyPath: keyPath].query(on: context.db).all() // Get the desired property and make the Fluent database query on it.
             }
         }, as: [TypeReference<ChildType>].self)
     }
 }
 
+// Parent Relationship
 extension Graphiti.Field where Arguments == NoArguments, Context == Request, ObjectType: Model {
+    
+    /// Creates a GraphQL field for a one-to-many/one-to-one relationship for Fluent
+    /// - Parameters:
+    ///   - name: Field name
+    ///   - keyPath: KeyPath to the @Parent property
     public convenience init<ParentType: Model>(
         _ name: FieldKey,
         with keyPath: KeyPath<ObjectType, ParentProperty<ObjectType, ParentType>>
-    ) where FieldType == TypeReference<ParentType>{
+    ) where FieldType == TypeReference<ParentType> {
         self.init(name.description, at: { (type) -> (Request, NoArguments, EventLoopGroup) throws -> EventLoopFuture<ParentType> in
             return { (context: Request, arguments: NoArguments, eventLoop: EventLoopGroup) in
-                return type[keyPath: keyPath].get(on: context.db)
+                return type[keyPath: keyPath].get(on: context.db)  // Get the desired property and make the Fluent database query on it.
             }
         }, as: TypeReference<ParentType>.self)
     }
 }
+
+// Siblings Relationship
+extension Graphiti.Field where Arguments == NoArguments, Context == Request, ObjectType: Model {
+    
+    /// Creates a GraphQL field for a many-to-many relationship for Fluent
+    /// - Parameters:
+    ///   - name: Field name
+    ///   - keyPath: KeyPath to the @Siblings property
+    public convenience init<ToType: Model, ThroughType: Model>(
+        _ name: FieldKey,
+        with keyPath: KeyPath<ObjectType, SiblingsProperty<ObjectType, ToType, ThroughType>>
+    ) where FieldType == [TypeReference<ToType>] {
+        self.init(name.description, at: { (type) -> (Request, NoArguments, EventLoopGroup) throws -> EventLoopFuture<[ToType]> in
+            return { (context: Request, arguments: NoArguments, eventLoop: EventLoopGroup) in
+                return type[keyPath: keyPath].query(on: context.db).all()  // Get the desired property and make the Fluent database query on it.
+            }
+        }, as: [TypeReference<ToType>].self)
+    }
+}