Custom JSON Coder for Postgres Coders (#129)

* Changed dependencies to Skelpo forks

* Added .encoder and .decoder properties to FluentPostgresDatabase

* Replaced PostgresRow:DatabaseRow with .databaseRow(using:) methods

* Pass custom PostgresData<Coder> instances as properties of _FluentPostgresDatabase

* Made PostgresRow.databaseRow(using:) method internal

* Created FluentPostgresDriverTests.testCustomJSON test case

* Replaced uses of PostgresRow.sqlRow with .sql

* Link to vapor/postgres-kit instead of Skelpo fork

* Fixed parameter name for PostgreDataDecoder parameter in .sql call

Author: calebkleveter

Sources/FluentPostgresDriver/FluentPostgresDatabase.swift

@@ -3,6 +3,9 @@ import FluentSQL
 struct _FluentPostgresDatabase {
     let database: PostgresDatabase
     let context: DatabaseContext
+
+    let encoder: PostgresDataEncoder
+    let decoder: PostgresDataDecoder
 }
 
 extension _FluentPostgresDatabase: Database {
@@ -16,8 +19,8 @@ extension _FluentPostgresDatabase: Database {
         }
         let (sql, binds) = self.serialize(expression)
         do {
-            return try self.query(sql, binds.map { try PostgresDataEncoder().encode($0) }) {
-                onRow($0)
+            return try self.query(sql, binds.map { try self.encoder.encode($0) }) {
+                onRow($0.databaseRow(using: self.decoder))
             }
         } catch {
             return self.eventLoop.makeFailedFuture(error)
@@ -29,7 +32,7 @@ extension _FluentPostgresDatabase: Database {
             .convert(schema)
         let (sql, binds) = self.serialize(expression)
         do {
-            return try self.query(sql, binds.map { try PostgresDataEncoder().encode($0) }) {
+            return try self.query(sql, binds.map { try self.encoder.encode($0) }) {
                 fatalError("unexpected row: \($0)")
             }
         } catch {
@@ -39,7 +42,7 @@ extension _FluentPostgresDatabase: Database {
 
     func withConnection<T>(_ closure: @escaping (Database) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
         self.database.withConnection {
-            closure(_FluentPostgresDatabase(database: $0, context: self.context))
+            closure(_FluentPostgresDatabase(database: $0, context: self.context, encoder: self.encoder, decoder: self.decoder))
         }
     }
 }
@@ -53,7 +56,7 @@ extension _FluentPostgresDatabase: SQLDatabase {
         sql query: SQLExpression,
         _ onRow: @escaping (SQLRow) -> ()
     ) -> EventLoopFuture<Void> {
-        self.sql().execute(sql: query, onRow)
+        self.sql(encoder: encoder, decoder: decoder).execute(sql: query, onRow)
     }
 }
 

Sources/FluentPostgresDriver/FluentPostgresDriver.swift

@@ -66,7 +66,9 @@ struct _FluentPostgresDriver: DatabaseDriver {
     func makeDatabase(with context: DatabaseContext) -> Database {
         _FluentPostgresDatabase(
             database: self.pool.pool(for: context.eventLoop).database(logger: context.logger),
-            context: context
+            context: context,
+            encoder: self.pool.source.configuration.encoder,
+            decoder: self.pool.source.configuration.decoder
         )
     }
 

Sources/FluentPostgresDriver/PostgresRow+Database.swift

@@ -1,13 +1,26 @@
-extension PostgresRow: DatabaseRow {
-    public func contains(field: String) -> Bool {
-        return self.column(field) != nil
+import class Foundation.JSONDecoder
+
+extension PostgresRow {
+    internal func databaseRow(using decoder: PostgresDataDecoder) -> DatabaseRow {
+        return _PostgresDatabaseRow(row: self, decoder: decoder)
+    }
+}
+
+private struct _PostgresDatabaseRow: DatabaseRow {
+    let row: PostgresRow
+    let decoder: PostgresDataDecoder
+
+    var description: String { self.row.description }
+
+    func contains(field: String) -> Bool {
+        return self.row.column(field) != nil
     }
 
-    public func decode<T>(
+    func decode<T>(
         field: String,
         as type: T.Type,
         for database: Database
     ) throws -> T where T : Decodable {
-        return try self.decode(column: field, as: T.self)
+        return try self.row.sql(decoder: self.decoder).decode(column: field, as: T.self)
     }
 }

Tests/FluentPostgresDriverTests/FluentPostgresDriverTests.swift

@@ -230,6 +230,52 @@ final class FluentPostgresDriverTests: XCTestCase {
         try new.save(on: self.db).wait()
     }
 
+    func testCustomJSON() throws {
+        struct Metadata: Codable {
+            let createdAt: Date
+        }
+
+        final class Event: Model {
+            static let schema = "events"
+
+            @ID(key: "id") var id: Int?
+            @Field(key: "metadata") var metadata: Metadata
+        }
+
+        struct EventMigration: Migration {
+            func prepare(on database: Database) -> EventLoopFuture<Void> {
+                return database.schema(Event.schema)
+                    .field("id", .int, .identifier(auto: true))
+                    .field("metadata", .json, .required)
+                    .create()
+            }
+
+            func revert(on database: Database) -> EventLoopFuture<Void> {
+                return database.schema(Event.schema).delete()
+            }
+        }
+
+        try EventMigration().prepare(on: self.db).wait()
+        defer { try! EventMigration().revert(on: self.db).wait() }
+
+        let date = Date()
+        let event = Event()
+        event.id = 1
+        event.metadata = Metadata(createdAt: date)
+        try event.save(on: self.db).wait()
+
+        let orm = Event.query(on: self.db).filter(\.$id == 1)
+        try self.db.execute(query: orm.query, onRow: { row in
+            do {
+                let metadata = try row.decode(field: "metadata", as: [String: String].self, for: self.db)
+                let expected = ISO8601DateFormatter().string(from: date)
+                XCTAssertEqual(metadata["createdAt"], expected)
+            } catch let error {
+                XCTFail(error.localizedDescription)
+            }
+        }).wait()
+    }
+
 
     var benchmarker: FluentBenchmarker {
         return .init(database: self.db)
@@ -242,17 +288,33 @@ final class FluentPostgresDriverTests: XCTestCase {
     }
 
     override func setUp() {
-        XCTAssert(isLoggingConfigured)
-        self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        let jsonEncoder = JSONEncoder()
+        jsonEncoder.dateEncodingStrategy = .iso8601
+
+        let jsonDecoder = JSONDecoder()
+        jsonDecoder.dateDecodingStrategy = .iso8601
+
         let hostname: String
         #if os(Linux)
         hostname = "psql"
         #else
         hostname = "localhost"
         #endif
+
+        let configuration = PostgresConfiguration(
+            hostname: hostname,
+            username: "vapor_username",
+            password: "vapor_password",
+            database: "vapor_database",
+            encoder: PostgresDataEncoder(json: jsonEncoder),
+            decoder: PostgresDataDecoder(json: jsonDecoder)
+        )
+
+        XCTAssert(isLoggingConfigured)
+        self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         self.threadPool = NIOThreadPool(numberOfThreads: 1)
         self.dbs = Databases(threadPool: threadPool, on: self.eventLoopGroup)
-        self.dbs.use(.postgres(hostname: hostname, username: "vapor_username", password: "vapor_password", database: "vapor_database"), as: .psql)
+        self.dbs.use(.postgres(configuration: configuration), as: .psql)
     }
 
     override func tearDown() {