beta 2: fluent db updates (#125)

* beta 2: fluent db updates

* psql id

* add withConnection

* withConnection updates

* sqlkit updates

* fix tests

* regen linuxmain

Author: tanner0101

Package.swift

@@ -7,8 +7,8 @@ let package = Package(
         .library(name: "FluentPostgresDriver", targets: ["FluentPostgresDriver"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/vapor/fluent-kit.git", from: "1.0.0-alpha.2"),
-        .package(url: "https://github.com/vapor/postgres-kit.git", from: "2.0.0-alpha.2"),
+        .package(url: "https://github.com/vapor/fluent-kit.git", .branch("master")),
+        .package(url: "https://github.com/vapor/postgres-kit.git", .branch("master")),
     ],
     targets: [
         .target(name: "FluentPostgresDriver", dependencies: [

Sources/FluentPostgresDriver/Databases+Postgres.swift

@@ -1,2 +1,8 @@
 @_exported import FluentKit
 @_exported import PostgresKit
+
+extension DatabaseID {
+    public static var psql: DatabaseID {
+        return .init(string: "psql")
+    }
+}

Sources/FluentPostgresDriver/Exports.swift

@@ -0,0 +1,80 @@
+import FluentSQL
+
+struct _FluentPostgresDatabase {
+    let database: PostgresDatabase
+    let context: DatabaseContext
+}
+
+extension _FluentPostgresDatabase: Database {
+    func execute(query: DatabaseQuery, onRow: @escaping (DatabaseRow) -> ()) -> EventLoopFuture<Void> {
+        var expression = SQLQueryConverter(delegate: PostgresConverterDelegate())
+            .convert(query)
+        switch query.action {
+        case .create:
+            expression = PostgresReturning(expression)
+        default: break
+        }
+        let (sql, binds) = self.serialize(expression)
+        do {
+            return try self.query(sql, binds.map { try PostgresDataEncoder().encode($0) }) {
+                onRow($0)
+            }
+        } catch {
+            return self.eventLoop.makeFailedFuture(error)
+        }
+    }
+
+    func execute(schema: DatabaseSchema) -> EventLoopFuture<Void> {
+        let expression = SQLSchemaConverter(delegate: PostgresConverterDelegate())
+            .convert(schema)
+        let (sql, binds) = self.serialize(expression)
+        do {
+            return try self.query(sql, binds.map { try PostgresDataEncoder().encode($0) }) {
+                fatalError("unexpected row: \($0)")
+            }
+        } catch {
+            return self.eventLoop.makeFailedFuture(error)
+        }
+    }
+    
+    func withConnection<T>(_ closure: @escaping (Database) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
+        self.database.withConnection {
+            closure(_FluentPostgresDatabase(database: $0, context: self.context))
+        }
+    }
+}
+
+extension _FluentPostgresDatabase: SQLDatabase {
+    var dialect: SQLDialect {
+        PostgresDialect()
+    }
+    
+    public func execute(
+        sql query: SQLExpression,
+        _ onRow: @escaping (SQLRow) -> ()
+    ) -> EventLoopFuture<Void> {
+        self.sql().execute(sql: query, onRow)
+    }
+}
+
+extension _FluentPostgresDatabase: PostgresDatabase {
+    func send(_ request: PostgresRequest, logger: Logger) -> EventLoopFuture<Void> {
+        self.database.send(request, logger: logger)
+    }
+    
+    func withConnection<T>(_ closure: @escaping (PostgresConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
+        self.database.withConnection(closure)
+    }
+}
+
+private struct PostgresReturning: SQLExpression {
+    let base: SQLExpression
+    init(_ base: SQLExpression) {
+        self.base = base
+    }
+
+    func serialize(to serializer: inout SQLSerializer) {
+        self.base.serialize(to: &serializer)
+        serializer.write(#" RETURNING id as "fluentID""#)
+    }
+}

Sources/FluentPostgresDriver/FluentPostgresDatabase.swift

@@ -0,0 +1,76 @@
+extension DatabaseDriverFactory {
+    public static func postgres(
+        url: URL,
+        maxConnectionsPerEventLoop: Int = 1
+    ) throws -> DatabaseDriverFactory {
+        guard let configuration = PostgresConfiguration(url: url) else {
+            throw FluentPostgresError.invalidURL(url)
+        }
+        return .postgres(
+            configuration: configuration,
+            maxConnectionsPerEventLoop: maxConnectionsPerEventLoop
+        )
+    }
+    
+    public static func postgres(
+        hostname: String,
+        port: Int = 5432,
+        username: String,
+        password: String,
+        database: String? = nil,
+        tlsConfiguration: TLSConfiguration? = nil,
+        maxConnectionsPerEventLoop: Int = 1
+    ) -> DatabaseDriverFactory {
+        return .postgres(
+            configuration: .init(
+                hostname: hostname,
+                port: port,
+                username: username,
+                password: password,
+                database: database,
+                tlsConfiguration: tlsConfiguration
+            ),
+            maxConnectionsPerEventLoop: maxConnectionsPerEventLoop
+        )
+    }
+    
+    public static func postgres(
+        configuration: PostgresConfiguration,
+        maxConnectionsPerEventLoop: Int = 1
+    ) -> DatabaseDriverFactory {
+        return DatabaseDriverFactory { databases in
+            let db = PostgresConnectionSource(
+                configuration: configuration
+            )
+            let pool = EventLoopGroupConnectionPool(
+                source: db,
+                maxConnectionsPerEventLoop: maxConnectionsPerEventLoop,
+                on: databases.eventLoopGroup
+            )
+            return _FluentPostgresDriver(pool: pool)
+        }
+    }
+}
+
+enum FluentPostgresError: Error {
+    case invalidURL(URL)
+}
+
+struct _FluentPostgresDriver: DatabaseDriver {
+    let pool: EventLoopGroupConnectionPool<PostgresConnectionSource>
+    
+    var eventLoopGroup: EventLoopGroup {
+        self.pool.eventLoopGroup
+    }
+    
+    func makeDatabase(with context: DatabaseContext) -> Database {
+        _FluentPostgresDatabase(
+            database: self.pool.pool(for: context.eventLoop).database(logger: context.logger),
+            context: context
+        )
+    }
+    
+    func shutdown() {
+        self.pool.shutdown()
+    }
+}

Sources/FluentPostgresDriver/FluentPostgresDriver.swift

@@ -100,8 +100,8 @@ final class FluentPostgresDriverTests: XCTestCase {
         try self.benchmarker.testTimestampable()
     }
 
-    func testLifecycleHooks() throws {
-        try self.benchmarker.testLifecycleHooks()
+    func testModelMiddleware() throws {
+        try self.benchmarker.testModelMiddleware()
     }
 
     func testSort() throws {
@@ -207,9 +207,10 @@ final class FluentPostgresDriverTests: XCTestCase {
         return .init(database: self.db)
     }
     var eventLoopGroup: EventLoopGroup!
+    var threadPool: NIOThreadPool!
     var dbs: Databases!
     var db: Database {
-        return self.dbs.default()
+        self.dbs.database(logger: .init(label: "codes.vapor.test"), on: self.eventLoopGroup.next())!
     }
 
     override func setUp() {
@@ -221,20 +222,14 @@ final class FluentPostgresDriverTests: XCTestCase {
         #else
         hostname = "localhost"
         #endif
-        let configuration = PostgresConfiguration(
-            hostname: hostname,
-            port: 5432,
-            username: "vapor_username",
-            password: "vapor_password",
-            database: "vapor_database",
-            tlsConfiguration: nil
-        )
-        self.dbs = Databases()
-        self.dbs.postgres(configuration: configuration, poolConfiguration: .init(maxConnections: 1), on: self.eventLoopGroup)
+        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"))
     }
 
     override func tearDown() {
         self.dbs.shutdown()
+        try! self.threadPool.syncShutdownGracefully()
         try! self.eventLoopGroup.syncShutdownGracefully()
     }
 }

Sources/FluentPostgresDriver/PostgresConnection+Database.swift

@@ -22,13 +22,19 @@ extension FluentPostgresDriverTests {
         ("testEagerLoadParentJSON", testEagerLoadParentJSON),
         ("testIdentifierGeneration", testIdentifierGeneration),
         ("testJoin", testJoin),
-        ("testLifecycleHooks", testLifecycleHooks),
         ("testMigrator", testMigrator),
         ("testMigratorError", testMigratorError),
+        ("testModelMiddleware", testModelMiddleware),
+        ("testMultipleJoinSameTable", testMultipleJoinSameTable),
         ("testNestedModel", testNestedModel),
+        ("testNewModelDecode", testNewModelDecode),
         ("testNullifyField", testNullifyField),
+        ("testParentGet", testParentGet),
+        ("testParentSerialization", testParentSerialization),
         ("testRead", testRead),
         ("testSaveModelWithBool", testSaveModelWithBool),
+        ("testSiblingsAttach", testSiblingsAttach),
+        ("testSiblingsEagerLoad", testSiblingsEagerLoad),
         ("testSoftDelete", testSoftDelete),
         ("testSort", testSort),
         ("testTimestampable", testTimestampable),