Swift 4.1 support. Switch to a more mature reflection dependency.

Author: jseibert

Package.resolved

@@ -1,5 +1,16 @@
+// swift-tools-version:4.0
 import PackageDescription
 
 let package = Package(
-    name: "GraphQL"
+    name: "GraphQL",
+    
+    dependencies: [
+        .package(url: "https://github.com/wickwirew/Runtime.git", .branch("swift-4.1")),
+    ],
+    
+    targets: [
+        .target(name: "GraphQL", dependencies: ["Runtime"]),
+        
+        .testTarget(name: "GraphQLTests", dependencies: ["GraphQL"]),
+    ]
 )

Package.swift

@@ -1,4 +1,5 @@
 import Dispatch
+import Runtime
 
 /**
  * Terminology
@@ -1128,7 +1129,12 @@ func defaultResolve(source: Any, args: Map, context: Any, info: GraphQLResolveIn
     }
 
     // TODO: check why Reflection fails
-    guard let value = try? get(info.fieldName, from: s) else {
+    guard let typeInfo = try? typeInfo(of: type(of: s)),
+        let property = try? typeInfo.property(named: info.fieldName) else {
+        return nil
+    }
+    
+    guard let value = try? property.get(from: s) else {
         return nil
     }
 

Sources/GraphQL/Execution/Execute.swift

@@ -1,20 +1,30 @@
+import Runtime
+
+enum RuntimeReflectionError: Error {
+    case requiredValueMissing(key: String)
+}
+
 extension MapInitializable {
     public init(map: Map) throws {
         guard case .dictionary(let dictionary) = map else {
             throw MapError.cannotInitialize(type: Self.self, from: try type(of: map.get()))
         }
-        self = try construct { property in
+        
+        self = try createInstance()
+        let info = try typeInfo(of: Self.self)
+        
+        for property in info.properties {
             guard let initializable = property.type as? MapInitializable.Type else {
                 throw MapError.notMapInitializable(property.type)
             }
-            switch dictionary[property.key] ?? .null {
+            switch dictionary[property.name] ?? .null {
             case .null:
                 guard let expressibleByNilLiteral = property.type as? ExpressibleByNilLiteral.Type else {
-                    throw ReflectionError.requiredValueMissing(key: property.key)
+                    throw RuntimeReflectionError.requiredValueMissing(key: property.name)
                 }
-                return expressibleByNilLiteral.init(nilLiteral: ())
+                try property.set(value: expressibleByNilLiteral.init(nilLiteral: ()), on: &self)
             case let x:
-                return try initializable.init(map: x)
+                try property.set(value: initializable.init(map: x), on: &self)
             }
         }
     }

Sources/GraphQL/Map/MapInitializable.swift

@@ -1,3 +1,5 @@
+import Runtime
+
 public func map(from value: Any?) throws -> Map {
     guard let value = value else {
         return .null
@@ -10,13 +12,14 @@ public func map(from value: Any?) throws -> Map {
     if let mapFallibleRepresentable = value as? MapFallibleRepresentable {
         return try mapFallibleRepresentable.asMap()
     }
-
-    let props = try properties(value)
+    
+    let info = try typeInfo(of: type(of: value))
+    let props = info.properties
 
     var dictionary = [String: Map](minimumCapacity: props.count)
 
     for property in props {
-        dictionary[property.key] = try map(from: property.value)
+        dictionary[property.name] = try map(from: property.get(from: value))
     }
 
     return .dictionary(dictionary)
@@ -31,20 +34,22 @@ public func assertMappable(_ type: Any.Type) throws {
         return
     }
 
-    for property in try properties(type) {
+    let info = try typeInfo(of: type)
+    for property in info.properties {
         try assertMappable(property.type)
     }
 }
 
 extension MapFallibleRepresentable {
     public func asMap() throws -> Map {
-        let props = try properties(self)
+        let info = try typeInfo(of: type(of: self))
+        let props = info.properties
         var dictionary = [String: Map](minimumCapacity: props.count)
         for property in props {
-            guard let representable = property.value as? MapFallibleRepresentable else {
-                throw MapError.notMapRepresentable(type(of: property.value))
+            guard let representable = try property.get(from: self) as? MapFallibleRepresentable else {
+                throw MapError.notMapRepresentable(property.type)
             }
-            dictionary[property.key] = try representable.asMap()
+            dictionary[property.name] = try representable.asMap()
         }
         return .dictionary(dictionary)
     }