Updates based on PR feedback

Author: Andrew Theis

Sources/PostgreSQL/Connection/PostgreSQLConnection+TCP.swift

@@ -7,7 +7,7 @@ extension PostgreSQLConnection {
     public static func connect(
         hostname: String = "localhost",
         port: Int = 5432,
-        transportConfig: PostgreSQLTransportConfig = .cleartext,
+        transport: PostgreSQLTransportConfig = .cleartext,
         on worker: Worker,
         onError: @escaping (Error) -> ()
     ) throws -> Future<PostgreSQLConnection> {
@@ -21,12 +21,13 @@ extension PostgreSQLConnection {
                 }
         }
 
-        return bootstrap.connect(host: hostname, port: port).flatMap(to: PostgreSQLConnection.self) { channel in
+        return bootstrap.connect(host: hostname, port: port).flatMap { channel in
             let connection = PostgreSQLConnection(queue: handler, channel: channel)
-            if case .tls(let tlsConfiguration) = transportConfig.method {
+            if case .tls(let tlsConfiguration) = transport.method {
                 return connection.addSSLClientHandler(using: tlsConfiguration).transform(to: connection)
+            } else {
+                return worker.eventLoop.newSucceededFuture(result: connection)
             }
-            return worker.eventLoop.newSucceededFuture(result: connection)
         }
     }
 }

Sources/PostgreSQL/Connection/PostgreSQLConnection.swift

@@ -137,7 +137,7 @@ public final class PostgreSQLConnection: DatabaseConnection, BasicWorker {
                 throw PostgreSQLError(identifier: "SSL support check", reason: "Unsupported message encountered during SSL support check: \(message).", source: .capture())
             }
             guard response == .supported else {
-                throw PostgreSQLError(identifier: "SSL support check", reason: "tlsConfiguration given in PostgresSQLConfiguration, but SSL connection not supported by PostgreSQL server", source: .capture())
+                throw PostgreSQLError(identifier: "SSL support check", reason: "tlsConfiguration given in PostgresSQLConfiguration, but SSL connection not supported by PostgreSQL server.", source: .capture())
             }
             return true
         }.flatMap {

Sources/PostgreSQL/Database/PostgreSQLDatabase.swift

@@ -19,7 +19,7 @@ public final class PostgreSQLDatabase: Database, LogSupporting {
     public func newConnection(on worker: Worker) -> Future<PostgreSQLConnection> {
         let config = self.config
         return Future.flatMap(on: worker) {
-            return try PostgreSQLConnection.connect(hostname: config.hostname, port: config.port, transportConfig: config.transportConfig, on: worker) { error in
+            return try PostgreSQLConnection.connect(hostname: config.hostname, port: config.port, transport: config.transportConfig, on: worker) { error in
                 print("[PostgreSQL] \(error)")
             }.flatMap(to: PostgreSQLConnection.self) { client in
                 return client.authenticate(

Sources/PostgreSQL/Database/PostgreSQLTransportConfig.swift

@@ -3,35 +3,36 @@ import NIOOpenSSL
 
 
 public struct PostgreSQLTransportConfig {
-    /// Does not attempt to enable TLS (this is the default)
+    /// Does not attempt to enable TLS (this is the default).
     public static var cleartext: PostgreSQLTransportConfig {
         return .init(method: .cleartext)
     }
 
-    /// Enables TLS requiring a minimum version of TLS v1.1 on the server, but disables certificate verification
-    /// This is what you would commonly use for paid Heroku PostgreSQL plans
+    /// Enables TLS requiring a minimum version of TLS v1.1 on the server, but disables certificate verification.
+    /// This is what you would commonly use for paid Heroku PostgreSQL plans.
     public static var unverifiedTLS: PostgreSQLTransportConfig {
         return .init(method: .tls(.forClient(certificateVerification: .none)))
     }
 
-    /// Enables TLS requiring a minimum version of TLS v1.1 on the server
+    /// Enables TLS requiring a minimum version of TLS v1.1 on the server.
     public static var standardTLS: PostgreSQLTransportConfig {
         return .init(method: .tls(.forClient()))
     }
 
-    /// Enables TLS requiring a minimum version of TLS v1.2 on the server
+    /// Enables TLS requiring a minimum version of TLS v1.2 on the server.
     public static var modernTLS: PostgreSQLTransportConfig {
         return .init(method: .tls(.forClient(minimumTLSVersion: .tlsv12)))
     }
 
-    /// Enables TLS requiring a minimum version of TLS v1.3 on the server
-    /// TLS v1.3 specification is still a draft and unlikely to be supported by most servers
-    /// See https://tools.ietf.org/html/draft-ietf-tls-tls13-28 for more info
+    /// Enables TLS requiring a minimum version of TLS v1.3 on the server.
+    /// TLS v1.3 specification is still a draft and unlikely to be supported by most servers.
+    /// See https://tools.ietf.org/html/draft-ietf-tls-tls13-28 for more info.
     public static var edgeTLS: PostgreSQLTransportConfig {
         return .init(method: .tls(.forClient(minimumTLSVersion: .tlsv13)))
     }
 
-    /// Enables TLS and allows you to use a set `TLSConfiguration`
+    /// Enables TLS using the given `TLSConfiguration`.
+    /// - parameter tlsConfiguration: See `TLSConfiguration` for more info.
     public static func customTLS(_ tlsConfiguration: TLSConfiguration)-> PostgreSQLTransportConfig {
         return .init(method: .tls(tlsConfiguration))
     }

Sources/PostgreSQL/Message+Parse/PostgreSQLMessageDecoder.swift

@@ -35,10 +35,10 @@ final class PostgreSQLMessageDecoder: ByteToMessageDecoder {
                 ctx.fireChannelRead(wrapInboundOut(message))
                 VERBOSE("   [message=\(message)]")
                 return .continue
+            } else {
+                VERBOSE("   [needMoreData: messageSize=nil]")
+                return .needMoreData
             }
-            
-            VERBOSE("   [needMoreData: messageSize=nil]")
-            return .needMoreData
         }
 
         /// ensure message is large enough or reject

Sources/PostgreSQL/Message/PostgreSQLSSLSupportResponse.swift

@@ -3,6 +3,8 @@ import Core
 /// Response given after sending a PostgreSQLSSLSupportRequest
 /// For more info, see https://www.postgresql.org/docs/10/static/protocol-flow.html#id-1.10.5.7.11
 enum PostgreSQLSSLSupportResponse: UInt8, Decodable {
+    /// The server supports SSL (char S).
     case supported = 0x53
+    /// The server does not support SSL (char N).
     case notSupported = 0x4E
 }

Tests/PostgreSQLTests/PostgreSQLConnectionTests.swift

@@ -14,7 +14,7 @@ class PostgreSQLConnectionTests: XCTestCase {
     }
 
     func testUnverifiedSSLConnection() throws {
-        let client = try PostgreSQLConnection.makeTest(transportConfig: .unverifiedTLS)
+        let client = try PostgreSQLConnection.makeTest(transport: .unverifiedTLS)
         let results = try client.simpleQuery("SELECT version();").wait()
         try XCTAssert(results[0].firstValue(forColumn: "version")?.decode(String.self).contains("10.") == true)
     }
@@ -468,17 +468,17 @@ extension PostgreSQLConnection {
     }
 
     /// Creates a test event loop and psql client over ssl
-    static func makeTest(transportConfig: PostgreSQLTransportConfig) throws -> PostgreSQLConnection {
+    static func makeTest(transport: PostgreSQLTransportConfig) throws -> PostgreSQLConnection {
         #if Xcode
-        return try _makeTest(hostname: self.dockerMachineHostname, port: 5433, transportConfig: transportConfig)
+        return try _makeTest(hostname: self.dockerMachineHostname, port: 5433, transport: transport)
         #else
-        return try _makeTest(hostname: "localhost-ssl", password: "vapor_password", transportConfig: transportConfig)
+        return try _makeTest(hostname: "localhost-ssl", password: "vapor_password", transport: transport)
         #endif
     }
 
-    private static func _makeTest(hostname: String, password: String? = nil, port: Int = 5432, transportConfig: PostgreSQLTransportConfig = .cleartext) throws -> PostgreSQLConnection {
+    private static func _makeTest(hostname: String, password: String? = nil, port: Int = 5432, transport: PostgreSQLTransportConfig = .cleartext) throws -> PostgreSQLConnection {
         let group = MultiThreadedEventLoopGroup(numThreads: 1)
-        let client = try PostgreSQLConnection.connect(hostname: hostname, port: port, transportConfig: transportConfig, on: group) { error in
+        let client = try PostgreSQLConnection.connect(hostname: hostname, port: port, transport: transport, on: group) { error in
             XCTFail("\(error)")
             }.wait()
         _ = try client.authenticate(username: "vapor_username", database: "vapor_database", password: password).wait()