Custom JSON Coders for Postgres Data Coders (vapor#159)

* Changed dependencies to Skelpo forks

* Conformed PostgresDataDecoder to PostrgesDecoder and PostgresDataEncoder to PostgresEncoder

* Added JSON encoder/decoder configurations to PostgresConfiguration initializer

* Added .encoder and .decoder properties to _ConnectionPoolPostgresDatabase extension

* Pass configuration.encoder and .decoder into PostgresConnection.connect call in PostgresConnectionSource.makeConnection method

* Use PostgresRow.decoder to decode data in PostgresRow.decode(column:as:) method

* Added .encoder and .decoder properties to _PostgresSQLDatabase

* Use .encoder to encode query binds in _PostgresSQLDatabase.execute(sql:onRow:) method

* Use .source instead of .sourceInfo propety in _ConnectionPoolPostgresDatabase.encoder and .decoder properties

* Use skeplo/master for PostgresNIO until forks are merged

* Replaced PostgresRow:SQLRow conformance with .sqlRow(using:) method

This results in an erased private _PostgreSQLRow struct instance that handles all the confrmance

* Replaced uses of Postgres<Coder> protocols with PostgresData<Coder> types

* Use original PostgresNIO library instead of Skelpo fork

* Fixed calls to PostgresConnection.sql(encoder:decoder:) in PostgresKitTests

* Deleted Xcode workspace

* Keep PostgresRow.sqlRow(using:) method internal

* Removed PostgresConnection.sql() extension method

* Pass in PostgresData coders instead of JSON coders to PostgresConfiguration init

* Removed leftover PostgresData coder declarations in PostgresConnection.test(on:) method

* Revert "Keep PostgresRow.sqlRow(using:) method internal"

This reverts commit 0fa2d80.

* Use registered JSONEncoder to handle DoJSON case in PostgresDataEncoder

* Added default value to PostgresDataEncoder.init(json:) and PostgresDataDecoder.init(json:) initializers

* Renamed PostgresRow.sqlRow(using:) method to .sql(using:)

* Replace uses of PostgresRow.sqlRow with .sql

* Revert all changes made for custom JSON

* Add default value to PostgresRow.sql method

Co-Authored-By: Tanner <me@tanner.xyz>

* Fix PostgresDataDecoder paramater name for .sql call

Author: calebkleveter

Diff for: Sources/PostgresKit/ConnectionPool+Postgres.swift

@@ -10,9 +10,7 @@ private struct _ConnectionPoolPostgresDatabase {
 }
 
 extension _ConnectionPoolPostgresDatabase: PostgresDatabase {
-    var eventLoop: EventLoop {
-        self.pool.eventLoop
-    }
+    var eventLoop: EventLoop { self.pool.eventLoop }
 
     func send(_ request: PostgresRequest, logger: Logger) -> EventLoopFuture<Void> {
         self.pool.withConnection(logger: logger) {

Diff for: Sources/PostgresKit/PostgresClient+SQL.swift

@@ -1,13 +1,20 @@
+import PostgresNIO
+import Foundation
 import SQLKit
 
 extension PostgresDatabase {
-    public func sql() -> SQLDatabase {
-        _PostgresSQLDatabase(database: self)
+    public func sql(
+        encoder: PostgresDataEncoder = PostgresDataEncoder(),
+        decoder: PostgresDataDecoder = PostgresDataDecoder()
+    ) -> SQLDatabase {
+        _PostgresSQLDatabase(database: self, encoder: encoder, decoder: decoder)
     }
 }
 
 private struct _PostgresSQLDatabase {
     let database: PostgresDatabase
+    let encoder: PostgresDataEncoder
+    let decoder: PostgresDataDecoder
 }
 
 extension _PostgresSQLDatabase: SQLDatabase {
@@ -27,9 +34,9 @@ extension _PostgresSQLDatabase: SQLDatabase {
         let (sql, binds) = self.serialize(query)
         do {
             return try self.database.query(sql, binds.map { encodable in
-                return try PostgresDataEncoder().encode(encodable)
+                return try self.encoder.encode(encodable)
             }) { row in
-                onRow(row)
+                onRow(row.sql(decoder: self.decoder))
             }
         } catch {
             return self.eventLoop.makeFailedFuture(error)

Diff for: Sources/PostgresKit/PostgresConfiguration.swift

@@ -1,12 +1,15 @@
-@_exported import struct Foundation.URL
+@_exported import Foundation
 
 public struct PostgresConfiguration {
     public let address: () throws -> SocketAddress
     public let username: String
     public let password: String
     public let database: String?
     public let tlsConfiguration: TLSConfiguration?
-    
+
+    public let encoder: PostgresDataEncoder
+    public let decoder: PostgresDataDecoder
+
     internal var _hostname: String?
 
     public init?(url: URL) {
@@ -49,7 +52,9 @@ public struct PostgresConfiguration {
         username: String,
         password: String,
         database: String? = nil,
-        tlsConfiguration: TLSConfiguration? = nil
+        tlsConfiguration: TLSConfiguration? = nil,
+        encoder: PostgresDataEncoder = PostgresDataEncoder(),
+        decoder: PostgresDataDecoder = PostgresDataDecoder()
     ) {
         self.address = {
             return try SocketAddress.makeAddressResolvingHost(hostname, port: port)
@@ -59,5 +64,7 @@ public struct PostgresConfiguration {
         self.password = password
         self.tlsConfiguration = tlsConfiguration
         self._hostname = hostname
+        self.encoder = encoder
+        self.decoder = decoder
     }
 }

Diff for: Sources/PostgresKit/PostgresDataDecoder.swift

@@ -7,16 +7,20 @@ struct DecoderUnwrapper: Decodable {
     }
 }
 
-public struct PostgresDataDecoder {
-    public init() {}
+public final class PostgresDataDecoder {
+    public let jsonDecoder: JSONDecoder
+
+    public init(json: JSONDecoder = JSONDecoder()) {
+        self.jsonDecoder = json
+    }
 
     public func decode<T>(_ type: T.Type, from data: PostgresData) throws -> T
         where T: Decodable
     {
         if let convertible = T.self as? PostgresDataConvertible.Type {
             return convertible.init(postgresData: data)! as! T
         } else {
-            return try T.init(from: _Decoder(data: data))
+            return try T.init(from: _Decoder(data: data, json: self.jsonDecoder))
         }
     }
 
@@ -30,8 +34,11 @@ public struct PostgresDataDecoder {
         }
 
         let data: PostgresData
-        init(data: PostgresData) {
+        let json: JSONDecoder
+
+        init(data: PostgresData, json: JSONDecoder) {
             self.data = data
+            self.json = json
         }
 
         func unkeyedContainer() throws -> UnkeyedDecodingContainer {
@@ -51,7 +58,7 @@ public struct PostgresDataDecoder {
                     debugDescription: "Cannot decode JSON from nil value"
                 ))
             }
-            let unwrapper = try JSONDecoder()
+            let unwrapper = try self.json
                 .decode(DecoderUnwrapper.self, from: Data(buffer.readableBytesView))
             return unwrapper.decoder
         }

Diff for: Sources/PostgresKit/PostgresDataEncoder.swift

@@ -1,7 +1,11 @@
 import Foundation
 
-public struct PostgresDataEncoder {
-    public init() { }
+public final class PostgresDataEncoder {
+    public let jsonEncoder: JSONEncoder
+
+    public init(json: JSONEncoder = JSONEncoder()) {
+        self.jsonEncoder = json
+    }
 
     public func encode(_ value: Encodable) throws -> PostgresData {
         if let custom = value as? PostgresDataConvertible {
@@ -12,7 +16,8 @@ public struct PostgresDataEncoder {
                 try value.encode(to: encoder)
                 return encoder.data
             } catch is DoJSON {
-                return try PostgresData(jsonb: Wrapper(value))
+                let data = try self.jsonEncoder.encode(Wrapper(value))
+                return PostgresData(jsonb: data)
             }
         }
     }

Diff for: Sources/PostgresKit/PostgresRow+SQL.swift

@@ -1,8 +1,17 @@
-extension PostgresRow: SQLRow {
-    public func decode<D>(column: String, as type: D.Type) throws -> D where D : Decodable {
-        guard let data = self.column(column) else {
+extension PostgresRow {
+    public func sql(decoder: PostgresDataDecoder = .init()) -> SQLRow {
+        return _PostgreSQLRow(row: self, decoder: decoder)
+    }
+}
+
+private struct _PostgreSQLRow: SQLRow {
+    let row: PostgresRow
+    let decoder: PostgresDataDecoder
+
+    func decode<D>(column: String, as type: D.Type) throws -> D where D : Decodable {
+        guard let data = self.row.column(column) else {
             fatalError()
         }
-        return try PostgresDataDecoder().decode(D.self, from: data)
+        return try self.decoder.decode(D.self, from: data)
     }
 }