EventLoop fixes

Author: MihaelIsaev

Package.swift

@@ -35,7 +35,7 @@ deps.append("https://github.com/vapor/mysql-nio.git", from: "1.0.0-beta.2", targ
 if localDev {
     deps.appendLocal("Bridges", targets: "Bridges")
 } else {
-    deps.append("https://github.com/SwifQL/Bridges.git", from: "1.0.0-beta.1", targets: "Bridges")
+    deps.append("https://github.com/SwifQL/Bridges.git", from: "1.0.0-beta.2", targets: "Bridges")
 }
 
 // MARK: - Package

README.md

@@ -15,8 +15,8 @@ Work with MySQL with SwifQL through its pure NIO driver.
 ## Installation
 
 ```swift
-.package(url: "https://github.com/SwifQL/MySQLBridge.git", from:"1.0.0-beta.1"),
-.package(url: "https://github.com/SwifQL/VaporBridges.git", from:"1.0.0-beta.1"),
+.package(url: "https://github.com/SwifQL/MySQLBridge.git", from:"1.0.0-beta.2"),
+.package(url: "https://github.com/SwifQL/VaporBridges.git", from:"1.0.0-beta.2"),
 .target(name: "App", dependencies: ["Vapor", "MySQLBridge", "VaporBridges"]),
 ```
 

Sources/MySQLBridge/Extensions/Bridges+Application.swift

@@ -9,21 +9,21 @@ import Bridges
 
 extension BridgesApplication {
     public var mysql: MySQLBridge {
-        bridges.bridge(to: MySQLBridge.self)
+        .init(bridges.bridge(to: _MySQLBridge.self, on: eventLoopGroup.next()))
     }
 }
 
 extension BridgesRequest {
     public var mysql: MySQLBridge {
-        bridgesApplication.mysql
+        .init(bridgesApplication.bridges.bridge(to: _MySQLBridge.self, on: eventLoop))
     }
 }
 
 import NIO
 import Logging
 
-extension MySQLBridge {
+extension _MySQLBridge {
     public static func create(eventLoopGroup: EventLoopGroup, logger: Logger) -> AnyBridge {
-        MySQLBridge(eventLoopGroup: eventLoopGroup, logger: logger)
+        _MySQLBridge(eventLoopGroup: eventLoopGroup, logger: logger)
     }
 }

Sources/MySQLBridge/MySQLBridge.swift

@@ -4,27 +4,54 @@ import AsyncKit
 import Bridges
 import Logging
 
-public final class MySQLBridge: Bridgeable {
-    public typealias Source = MySQLConnectionSource
-    public typealias Database = MySQLDatabase
-    public typealias Connection = MySQLConnection
+public struct MySQLBridge {
+    let context: BridgeWithContext<_MySQLBridge>
+        
+    init (_ context: BridgeWithContext<_MySQLBridge>) {
+        self.context = context
+    }
+    
+    public func connection<T>(to db: DatabaseIdentifier,
+                                            _ closure: @escaping (MySQLConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
+        context.bridge.connection(to: db, on: context.eventLoop, closure)
+    }
+    
+    public func transaction<T>(to db: DatabaseIdentifier,
+                                            _ closure: @escaping (MySQLConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
+        context.bridge.transaction(to: db, on: context.eventLoop, closure)
+    }
+    
+    public func register(_ db: DatabaseIdentifier) {
+        context.bridge.register(db)
+    }
 
-    public static var dialect: SQLDialect { .mysql }
+    public func migrator(for db: DatabaseIdentifier) -> Migrator {
+        BridgeDatabaseMigrations<_MySQLBridge>(context.bridge, db: db)
+    }
+}
+
+final class _MySQLBridge: Bridgeable {
+    typealias Source = MySQLConnectionSource
+    typealias Database = MySQLDatabase
+    typealias Connection = MySQLConnection
+    
+    static var dialect: SQLDialect { .mysql }
 
-    public var pools: [String: GroupPool] = [:]
+    var pools: [String: GroupPool] = [:]
 
-    public let logger: Logger
-    public let eventLoopGroup: EventLoopGroup
+    let logger: Logger
+    let eventLoopGroup: EventLoopGroup
 
-    required public init (eventLoopGroup: EventLoopGroup, logger: Logger) {
+    required init (eventLoopGroup: EventLoopGroup, logger: Logger) {
         self.eventLoopGroup = eventLoopGroup
         self.logger = logger
     }
 
     /// Gives a connection to the database and closes it automatically in both success and error cases
-    public func connection<T>(to db: DatabaseIdentifier,
-                                           _ closure: @escaping (MySQLConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
-        self.db(db).withConnection { conn in
+    func connection<T>(to db: DatabaseIdentifier,
+                                  on eventLoop: EventLoop,
+                                  _ closure: @escaping (MySQLConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
+        self.db(db, on: eventLoop).withConnection { conn in
             closure(conn).flatMap { result in
                 if conn.isClosed {
                     return conn.eventLoop.future(result)
@@ -43,8 +70,8 @@ public final class MySQLBridge: Bridgeable {
         }
     }
 
-    public func db(_ db: DatabaseIdentifier) -> MySQLDatabase {
-        _ConnectionPoolMySQLDatabase(pool: pool(db), logger: logger)
+    func db(_ db: DatabaseIdentifier, on eventLoop: EventLoop) -> MySQLDatabase {
+        _ConnectionPoolMySQLDatabase(pool: pool(db, for: eventLoop), logger: logger, eventLoop: eventLoop)
     }
 
     deinit {
@@ -55,21 +82,18 @@ public final class MySQLBridge: Bridgeable {
 // MARK: Database on pool
 
 extension EventLoopConnectionPool where Source == MySQLConnectionSource {
-    public func database(logger: Logger) -> MySQLDatabase {
-        _ConnectionPoolMySQLDatabase(pool: self, logger: logger)
+    public func database(logger: Logger, on eventLoop: EventLoop) -> MySQLDatabase {
+        _ConnectionPoolMySQLDatabase(pool: self, logger: logger, eventLoop: eventLoop)
     }
 }
 
 private struct _ConnectionPoolMySQLDatabase {
     let pool: EventLoopConnectionPool<MySQLConnectionSource>
     let logger: Logger
+    let eventLoop: EventLoop
 }
 
 extension _ConnectionPoolMySQLDatabase: MySQLDatabase {
-    var eventLoop: EventLoop {
-        self.pool.eventLoop
-    }
-    
     func send(_ command: MySQLCommand, logger: Logger) -> EventLoopFuture<Void> {
         self.pool.withConnection(logger: logger) {
             $0.send(command, logger: logger)