Track Migrations Per Database

Sources/FluentBenchmark/FluentBenchmarker.swift

@@ -5,6 +5,7 @@ import XCTest
 
 public final class FluentBenchmarker {
     public let databases: Databases
+    public let ids: (DatabaseID, DatabaseID)
 
     public var database: Database {
         self.databases.database(
@@ -13,8 +14,11 @@ public final class FluentBenchmarker {
         )!
     }
 
-    public init(databases: Databases) {
+    public init(databases: Databases, _ ids: (DatabaseID, DatabaseID)) {
+        precondition(ids.0 != ids.1, "FluentBecnhmarker DatabaseIDs must be non-equivalent")
+
         self.databases = databases
+        self.ids = ids
     }
 
     public func testAll() throws {

Sources/FluentBenchmark/Tests/MigratorTests.swift

@@ -2,6 +2,7 @@ extension FluentBenchmarker {
     public func testMigrator() throws {
         try self.testMigrator_success()
         try self.testMigrator_error()
+        try self.testMigrator_sequence()
     }
 
     private func testMigrator_success() throws {
@@ -53,6 +54,80 @@ extension FluentBenchmarker {
             try migrator.revertAllBatches().wait()
         }
     }
+
+    private func testMigrator_sequence() throws {
+        try self.runTest(#function, []) {
+
+            // Setup
+            let database1 = try XCTUnwrap(
+                self.databases.database(
+                    self.ids.0,
+                    logger: Logger(label: "codes.vapor.tests"),
+                    on: self.databases.eventLoopGroup.next()
+                )
+            )
+            let database2 = try XCTUnwrap(
+                self.databases.database(
+                    self.ids.1,
+                    logger: Logger(label: "codes.vapor.tests"),
+                    on: self.databases.eventLoopGroup.next()
+                )
+            )
+
+            let migrations = Migrations()
+
+
+            // Migration #1
+            migrations.add(GalaxyMigration(), to: self.ids.0)
+
+            let migrator = Migrator(
+                databases: self.databases,
+                migrations: migrations,
+                logger: Logger(label: "codes.vapor.tests"),
+                on: self.databases.eventLoopGroup.next()
+            )
+
+            try migrator.setupIfNeeded().wait()
+            try migrator.prepareBatch().wait()
+
+            let logs1 = try MigrationLog.query(on: database1).all().wait()
+            XCTAssertEqual(logs1.count, 1)
+            let log1 = try XCTUnwrap(logs1.first)
+            XCTAssertEqual(log1.batch, 1)
+            XCTAssertEqual(log1.name, "\(GalaxyMigration.self)")
+
+            do {
+                let count = try MigrationLog.query(on: database2).count().wait()
+
+                // This is a valid state to enter. Unlike database in the SQL family,
+                // some databases such as MongoDB won't throw an error if the table doesn't exist.
+                XCTAssertEqual(count, 0)
+            } catch let error {
+                // This is a valid state to enter. A SQL database with throw an error
+                // because the `_fluent_migrations` table on the `database2` database
+                // will have not been created yet.
+            }
+
+
+            // Migration #2
+            migrations.add(GalaxyMigration(), to: self.ids.1)
+
+            try migrator.setupIfNeeded().wait()
+            try migrator.prepareBatch().wait()
+
+            let logs2 = try MigrationLog.query(on: database2).all().wait()
+            XCTAssertEqual(logs2.count, 1)
+            let log2 = try XCTUnwrap(logs2.first)
+            XCTAssertEqual(log2.batch, 1)
+            XCTAssertEqual(log2.name, "\(GalaxyMigration.self)")
+
+            try XCTAssertEqual(MigrationLog.query(on: database1).count().wait(), 1)
+
+
+            // Teardown
+            try migrator.revertAllBatches().wait()
+        }
+    }
 }
 
 private struct ErrorMigration: Migration {

Sources/FluentKit/Database/Databases.swift

@@ -3,10 +3,22 @@ import class NIOConcurrencyHelpers.Lock
 @_exported import class NIO.NIOThreadPool
 
 public struct DatabaseConfigurationFactory {
-    public let make: () -> DatabaseConfiguration
+    private let build: (DatabaseID?) -> DatabaseConfiguration
+
+    public var make: () -> DatabaseConfiguration {
+        return { self.build(nil) }
+    }
 
     public init(make: @escaping () -> DatabaseConfiguration) {
-        self.make = make
+        self.build = { _ in make() }
+    }
+
+    public init(make: @escaping (DatabaseID?) -> DatabaseConfiguration) {
+        self.build = make
+    }
+
+    public func make(_ id: DatabaseID?) -> DatabaseConfiguration {
+        return self.build(id)
     }
 }
 
@@ -57,7 +69,7 @@ public final class Databases {
         as id: DatabaseID,
         isDefault: Bool? = nil
     ) {
-        self.use(configuration.make(), as: id, isDefault: isDefault)
+        self.use(configuration.make(id), as: id, isDefault: isDefault)
     }
 
     public func use(

Sources/FluentKit/Migration/Migrations.swift

@@ -5,12 +5,15 @@ public final class Migrations {
     }
 
     var storage: [Item]
+    var databases: Set<DatabaseID>
 
     public init() {
         self.storage = []
+        self.databases = []
     }
 
     public func add(_ migration: Migration, to id: DatabaseID? = nil) {
         self.storage.append(.init(id: id, migration: migration))
+        if let id = id { self.databases.insert(id) }
     }
 }