Removing getters from property wrappers from objects

Sources/GraphZahl/Resolution/OutputResolvable/Implementations/Object/GraphQLObject+resolve.swift

@@ -8,27 +8,15 @@ extension GraphQLObject {
     static func resolveObject(using context: inout Resolution.Context) throws -> GraphQLObjectType {
         let (typeProperties, typeMethods, inheritance) = try typeInfo(of: Self.self, .properties, .methods, .inheritance)
 
+        let gettersThatShouldBeIgnored = Set(typeProperties.filter { $0.type is CustomGraphQLProperty.Type }.map { $0.name.deleting(prefix: "_") })
         let propertyResults = try typeProperties.compactMap { try $0.resolve(for: Self.self, using: &context) }
         let properties = propertyResults.reduce([:]) { dictionary, result in
             return dictionary.merging(result.fieldMap) { first, _ in first }
         }
 
         let methodMap = Dictionary(typeMethods.map { ($0.methodName.deleting(prefix: "$"), $0) }) { first, _ in first }
-        let methods = try methodMap.compactMapValues { try $0.resolve(for: Self.self, using: &context) }
-
-        let fields = properties.merging(methods) { property, method in
-            guard method.args.isEmpty else { return method }
-
-            if property.type.debugDescription == method.type.debugDescription {
-                return property
-            }
-
-            if property.args.isEmpty {
-                return method
-            } else {
-                return property
-            }
-        }
+        let methods = try methodMap.filter { !gettersThatShouldBeIgnored.contains($0.key) }.compactMapValues { try $0.resolve(for: Self.self, using: &context) }
+        let fields = properties.merging(methods) { $1 }
 
         let interfaces = try inheritance
             .compactMap { $0 as? GraphQLObject.Type }

Sources/GraphZahl/Utils/Ignore.swift → Sources/GraphZahl/Resolution/OutputResolvable/Implementations/Object/PropertyWrappers/Ignore.swift

@@ -1,15 +1,26 @@
 
 import Foundation
+import Runtime
 
 @propertyWrapper
-public struct Ignore<T> {
+public struct Ignore<T : OutputResolvable> {
     public var wrappedValue: T
 
     public init(wrappedValue: T) {
         self.wrappedValue = wrappedValue
     }
 }
 
+extension Ignore: CustomGraphQLProperty {
+
+    static func resolve(with property: PropertyInfo,
+                        for receiverType: GraphQLObject.Type,
+                        using context: inout Resolution.Context) throws -> PropertyResult {
+        return .ignore
+    }
+
+}
+
 extension Ignore: Encodable where T: Encodable {
 
     public func encode(to encoder: Encoder) throws {

Sources/GraphZahl/Resolution/OutputResolvable/Implementations/Object/PropertyResult.swift → Sources/GraphZahl/Resolution/OutputResolvable/Implementations/Object/PropertyWrappers/PropertyResult.swift

@@ -4,6 +4,7 @@ import GraphQL
 enum PropertyResult {
     case field(String, GraphQLField)
     case interface(GraphQLInterfaceType, fields: [String : GraphQLField])
+    case ignore
 }
 
 extension PropertyResult {
@@ -14,6 +15,8 @@ extension PropertyResult {
             return [name : field]
         case .interface(_, let fields):
             return fields
+        case .ignore:
+            return [:]
         }
     }