Upgrade DatabaseIdentifier 🍓 and implement conveniences

Author: MihaelIsaev

Sources/MySQLBridge/Extensions/Bridges+Application.swift

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

Sources/MySQLBridge/Extensions/DatabaseIdentifier+Initialization.swift

@@ -11,13 +11,33 @@ import Bridges
 extension DatabaseIdentifier {
     /// Initialize identifier based on `MYSQL_DB` environment variable
     public static var mysqlEnvironment: DatabaseIdentifier {
-        .init(name: ProcessInfo.processInfo.environment["MYSQL_DB"], host: .mysqlEnvironment, maxConnectionsPerEventLoop: 1)
+        MySQLDatabaseIdentifier(name: ProcessInfo.processInfo.environment["MYSQL_DB"], host: .mysqlEnvironment, maxConnectionsPerEventLoop: 1)
     }
+    
+    public static func mysql(name: String? = ProcessInfo.processInfo.environment["MYSQL_DB"], host: DatabaseHost, maxConnectionsPerEventLoop: Int = 1) -> DatabaseIdentifier {
+        MySQLDatabaseIdentifier(name: name, host: host, maxConnectionsPerEventLoop: maxConnectionsPerEventLoop)
+    }
+}
 
-    public init?(url: URL, maxConnectionsPerEventLoop: Int = 1) {
+public class MySQLDatabaseIdentifier: DatabaseIdentifier, MySQLDatabaseIdentifiable {
+    public  typealias B = MBR
+    
+    public convenience init?(url: URL, maxConnectionsPerEventLoop: Int = 1) {
         guard let host = DatabaseHost(url: url) else {
             return nil
         }
         self.init(name: url.path.split(separator: "/").last.flatMap(String.init), host: host, maxConnectionsPerEventLoop: maxConnectionsPerEventLoop)
     }
+    
+    public func all<T>(_ table: T.Type, on bridges: AnyBridgesObject) -> EventLoopFuture<[T]> where T : Table {
+        MySQLBridge(bridges.bridges.bridge(to: B.self, on: bridges.eventLoop)).connection(to: self) { conn in
+            T.select.execute(on: conn).all(decoding: T.self)
+        }
+    }
+    
+    public func first<T>(_ table: T.Type, on bridges: AnyBridgesObject) -> EventLoopFuture<T?> where T : Table {
+        MySQLBridge(bridges.bridges.bridge(to: B.self, on: bridges.eventLoop)).connection(to: self) { conn in
+            T.select.execute(on: conn).first(decoding: T.self)
+        }
+    }
 }

Sources/MySQLBridge/MySQLBridge.swift

@@ -4,10 +4,10 @@ import AsyncKit
 import Bridges
 import Logging
 
-public struct MySQLBridge {
-    let context: BridgeWithContext<_MySQLBridge>
+public struct MySQLBridge: ContextBridgeable {
+    public let context: BridgeWithContext<MBR>
 
-    init (_ context: BridgeWithContext<_MySQLBridge>) {
+    init (_ context: BridgeWithContext<MBR>) {
         self.context = context
     }
 
@@ -26,35 +26,35 @@ public struct MySQLBridge {
     }
 
     public func migrator(for db: DatabaseIdentifier) -> Migrator {
-        BridgeDatabaseMigrations<_MySQLBridge>(context.bridge, db: db)
+        BridgeDatabaseMigrations<MBR>(context.bridge, db: db)
     }
 }
 
-final class _MySQLBridge: Bridgeable {
-    typealias Source = MySQLConnectionSource
-    typealias Database = MySQLDatabase
-    typealias Connection = MySQLConnection
+public final class MBR: Bridgeable {
+    public typealias Source = MySQLConnectionSource
+    public typealias Database = MySQLDatabase
+    public typealias Connection = MySQLConnection
 
-    static var dialect: SQLDialect { .mysql }
+    public static var dialect: SQLDialect { .mysql }
 
-    var pools: [String: GroupPool] = [:]
+    public var pools: [String: GroupPool] = [:]
 
-    let logger: Logger
-    let eventLoopGroup: EventLoopGroup
+    public let logger: Logger
+    public let eventLoopGroup: EventLoopGroup
 
-    required init (eventLoopGroup: EventLoopGroup, logger: Logger) {
+    public 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
-    func connection<T>(to db: DatabaseIdentifier,
+    public func connection<T>(to db: DatabaseIdentifier,
                                   on eventLoop: EventLoop,
                                   _ closure: @escaping (MySQLConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
         self.db(db, on: eventLoop).withConnection { closure($0) }
     }
 
-    func db(_ db: DatabaseIdentifier, on eventLoop: EventLoop) -> MySQLDatabase {
+    public func db(_ db: DatabaseIdentifier, on eventLoop: EventLoop) -> MySQLDatabase {
         _ConnectionPoolMySQLDatabase(pool: pool(db, for: eventLoop), logger: logger, eventLoop: eventLoop)
     }