Convert ELF to async await

Sources/App/Commands/Analyze.swift

@@ -196,7 +196,7 @@ extension Analyze {
             }
 
             for (version, pkgInfo) in versionsPkgInfo {
-                try await updateVersion(on: tx, version: version, packageInfo: pkgInfo).get()
+                try await updateVersion(on: tx, version: version, packageInfo: pkgInfo)
                 try await recreateProducts(on: tx, version: version, manifest: pkgInfo.packageManifest)
                 try await recreateTargets(on: tx, version: version, manifest: pkgInfo.packageManifest)
             }
@@ -567,7 +567,7 @@ extension Analyze {
     /// - Returns: future
     static func updateVersion(on database: Database,
                               version: Version,
-                              packageInfo: PackageInfo) -> EventLoopFuture<Void> {
+                              packageInfo: PackageInfo) async throws {
         let manifest = packageInfo.packageManifest
         version.packageName = manifest.name
         version.swiftVersions = manifest.swiftLanguageVersions?.compactMap(SwiftVersion.init) ?? []
@@ -576,13 +576,13 @@ extension Analyze {
         version.spiManifest = packageInfo.spiManifest
         version.hasBinaryTargets = packageInfo.packageManifest.targets.contains { $0.type == .binary }
 
-        return version.save(on: database)
+        try await version.save(on: database)
     }
 
 
     static func recreateProducts(on database: Database, version: Version, manifest: Manifest) async throws {
-        try await deleteProducts(on: database, version: version).get()
-        try await createProducts(on: database, version: version, manifest: manifest).get()
+        try await deleteProducts(on: database, version: version)
+        try await createProducts(on: database, version: version, manifest: manifest)
     }
 
 
@@ -591,11 +591,9 @@ extension Analyze {
     ///   - database: database connection
     ///   - version: parent model object
     /// - Returns: future
-    static func deleteProducts(on database: Database, version: Version) -> EventLoopFuture<Void> {
-        guard let versionId = version.id else {
-            return database.eventLoop.future()
-        }
-        return Product.query(on: database)
+    static func deleteProducts(on database: Database, version: Version) async throws {
+        guard let versionId = version.id else { return }
+        try await Product.query(on: database)
             .filter(\.$version.$id == versionId)
             .delete()
     }
@@ -607,8 +605,8 @@ extension Analyze {
     ///   - version: version to update
     ///   - manifest: `Manifest` data
     /// - Returns: future
-    static func createProducts(on database: Database, version: Version, manifest: Manifest) -> EventLoopFuture<Void> {
-        manifest.products.compactMap { manifestProduct in
+    static func createProducts(on database: Database, version: Version, manifest: Manifest) async throws {
+        try await manifest.products.compactMap { manifestProduct in
             try? Product(version: version,
                          type: .init(manifestProductType: manifestProduct.type),
                          name: manifestProduct.name,
@@ -619,8 +617,8 @@ extension Analyze {
 
 
     static func recreateTargets(on database: Database, version: Version, manifest: Manifest) async throws {
-        try await deleteTargets(on: database, version: version).get()
-        try await createTargets(on: database, version: version, manifest: manifest).get()
+        try await deleteTargets(on: database, version: version)
+        try await createTargets(on: database, version: version, manifest: manifest)
     }
 
 
@@ -629,11 +627,9 @@ extension Analyze {
     ///   - database: database connection
     ///   - version: parent model object
     /// - Returns: future
-    static func deleteTargets(on database: Database, version: Version) -> EventLoopFuture<Void> {
-        guard let versionId = version.id else {
-            return database.eventLoop.future()
-        }
-        return Target.query(on: database)
+    static func deleteTargets(on database: Database, version: Version) async throws {
+        guard let versionId = version.id else { return }
+        try await Target.query(on: database)
             .filter(\.$version.$id == versionId)
             .delete()
     }
@@ -645,8 +641,8 @@ extension Analyze {
     ///   - version: version to update
     ///   - manifest: `Manifest` data
     /// - Returns: future
-    static func createTargets(on database: Database, version: Version, manifest: Manifest) -> EventLoopFuture<Void> {
-        manifest.targets.compactMap {
+    static func createTargets(on database: Database, version: Version, manifest: Manifest) async throws {
+        try await manifest.targets.compactMap {
             try? Target(version: version, name: $0.name, type: .init(manifestTargetType: $0.type))
         }
         .create(on: database)

Sources/App/Commands/Common.swift

@@ -19,8 +19,6 @@ import Vapor
 
 /// Update packages (in the `[Result<Joined<Package, Repository>, Error>]` array).
 ///
-/// Unlike the overload with a result parameter `Result<(Joined<Package, Repository>, [Version])` this will not use `Version` information to update the package.
-///
 /// - Parameters:
 ///   - client: `Client` object
 ///   - database: `Database` object

Sources/App/Commands/ReAnalyzeVersions.swift

@@ -201,15 +201,9 @@ enum ReAnalyzeVersions {
                         continue
                     }
 
-                    try await Analyze.updateVersion(on: tx,
-                                                    version: version,
-                                                    packageInfo: pkgInfo).get()
-                    try await Analyze.recreateProducts(on: tx,
-                                                       version: version,
-                                                       manifest: pkgInfo.packageManifest)
-                    try await Analyze.recreateTargets(on: tx,
-                                                      version: version,
-                                                      manifest: pkgInfo.packageManifest)
+                    try await Analyze.updateVersion(on: tx, version: version, packageInfo: pkgInfo)
+                    try await Analyze.recreateProducts(on: tx, version: version, manifest: pkgInfo.packageManifest)
+                    try await Analyze.recreateTargets(on: tx, version: version, manifest: pkgInfo.packageManifest)
                 }
 
                 // No need to run `updateLatestVersions` because we're only operating on existing versions,

Sources/App/Core/Extensions/Model+ext.swift

@@ -16,12 +16,6 @@ import Fluent
 
 
 extension Array where Element: FluentKit.Model {
-    public func save(on database: Database) -> EventLoopFuture<Void> {
-        map {
-            $0.save(on: database)
-        }.flatten(on: database.eventLoop)
-    }
-
     public func save(on database: Database) async throws -> Void {
         for element in self {
             try await element.save(on: database)

Tests/AppTests/AnalyzerTests.swift

@@ -746,10 +746,10 @@ class AnalyzerTests: AppTestCase {
         XCTAssertEqual(info.packageManifest.name, "SPI-Server")
     }
 
-    func test_updateVersion() throws {
+    func test_updateVersion() async throws {
         // setup
         let pkg = Package(id: UUID(), url: "1")
-        try pkg.save(on: app.db).wait()
+        try await pkg.save(on: app.db)
         let version = try Version(package: pkg, reference: .branch("main"))
         let manifest = Manifest(name: "foo",
                                 platforms: [.init(platformName: .ios, version: "11.0"),
@@ -767,13 +767,12 @@ class AnalyzerTests: AppTestCase {
             """)
 
         // MUT
-        _ = try Analyze.updateVersion(on: app.db,
-                                      version: version,
-                                      packageInfo: .init(packageManifest: manifest,
-                                                         spiManifest: spiManifest)).wait()
+        _ = try await Analyze.updateVersion(on: app.db,
+                                            version: version,
+                                            packageInfo: .init(packageManifest: manifest, spiManifest: spiManifest))
 
         // read back and validate
-        let v = try Version.query(on: app.db).first().wait()!
+        let v = try await XCTUnwrapAsync(await Version.query(on: app.db).first())
         XCTAssertEqual(v.packageName, "foo")
         XCTAssertEqual(v.resolvedDependencies?.map(\.packageName), nil)
         XCTAssertEqual(v.swiftVersions, ["1", "2", "3.0.0"].asSwiftVersions)
@@ -782,7 +781,7 @@ class AnalyzerTests: AppTestCase {
         XCTAssertEqual(v.spiManifest, spiManifest)
     }
 
-    func test_createProducts() throws {
+    func test_createProducts() async throws {
         // setup
         let p = Package(id: UUID(), url: "1")
         let v = try Version(id: UUID(), package: p, packageName: "1", reference: .tag(.init(1, 0, 0)))
@@ -795,35 +794,35 @@ class AnalyzerTests: AppTestCase {
                                           type: .executable)],
                          targets: [],
                          toolsVersion: .init(version: "5.0.0"))
-        try p.save(on: app.db).wait()
-        try v.save(on: app.db).wait()
+        try await p.save(on: app.db)
+        try await v.save(on: app.db)
 
         // MUT
-        try Analyze.createProducts(on: app.db, version: v, manifest: m).wait()
+        try await Analyze.createProducts(on: app.db, version: v, manifest: m)
 
         // validation
-        let products = try Product.query(on: app.db).sort(\.$createdAt).all().wait()
+        let products = try await Product.query(on: app.db).sort(\.$createdAt).all()
         XCTAssertEqual(products.map(\.name), ["p1", "p2"])
         XCTAssertEqual(products.map(\.targets), [["t1", "t2"], ["t3", "t4"]])
         XCTAssertEqual(products.map(\.type), [.library(.automatic), .executable])
     }
 
-    func test_createTargets() throws {
+    func test_createTargets() async throws {
         // setup
         let p = Package(id: UUID(), url: "1")
         let v = try Version(id: UUID(), package: p, packageName: "1", reference: .tag(.init(1, 0, 0)))
         let m = Manifest(name: "1",
                          products: [],
                          targets: [.init(name: "t1", type: .regular), .init(name: "t2", type: .executable)],
                          toolsVersion: .init(version: "5.0.0"))
-        try p.save(on: app.db).wait()
-        try v.save(on: app.db).wait()
+        try await p.save(on: app.db)
+        try await v.save(on: app.db)
 
         // MUT
-        try Analyze.createTargets(on: app.db, version: v, manifest: m).wait()
+        try await Analyze.createTargets(on: app.db, version: v, manifest: m)
 
         // validation
-        let targets = try Target.query(on: app.db).sort(\.$createdAt).all().wait()
+        let targets = try await Target.query(on: app.db).sort(\.$createdAt).all()
         XCTAssertEqual(targets.map(\.name), ["t1", "t2"])
         XCTAssertEqual(targets.map(\.type), [.regular, .executable])
     }

Tests/AppTests/ArrayExtensionTests.swift

@@ -22,77 +22,6 @@ import SPIManifest
 
 class ArrayExtensionTests: XCTestCase {
 
-    func test_map_Result_to_EventLoopFuture() throws {
-        // setup
-        let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        let results = [0, 1, 2].map { Result<Int, Error>.success($0) }
-
-        // MUT
-        let mapped = results.map(on: elg.next()) {
-            elg.future(String($0))
-        }
-
-        // validate
-        let res = try mapped.flatten(on: elg.next()).wait()
-        XCTAssertEqual(res, ["0", "1", "2"])
-    }
-
-    func test_map_Result_to_EventLoopFuture_with_errors() throws {
-        // setup
-        enum MyError: Error, Equatable { case failed }
-        let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        let results: [Result<Int, MyError>] = [
-            .success(0),
-            .failure(MyError.failed),
-            .success(2)
-        ]
-
-        // MUT
-        let mapped = results.map(on: elg.next()) {
-            elg.future(String($0))
-        }
-
-        // validate
-        XCTAssertEqual(try mapped[0].wait(), "0")
-        XCTAssertThrowsError(try mapped[1].wait()) {
-            XCTAssertEqual($0 as? MyError, MyError.failed)
-        }
-        XCTAssertEqual(try mapped[2].wait(), "2")
-    }
-
-    func test_whenAllComplete() throws {
-        // setup
-        let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        let results = [0, 1, 2].map { Result<Int, Error>.success($0) }
-
-        // MUT
-        let res = try results.whenAllComplete(on: elg.next()) {
-            elg.future(String($0))
-        }.wait()
-
-        // validate
-        XCTAssertEqual(res.compactMap { try? $0.get() }, ["0", "1", "2"])
-    }
-
-    func test_whenAllComplete_with_errors() throws {
-        // setup
-        enum MyError: Error { case failed }
-        let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        let results: [Result<Int, Error>] = [
-            .success(0),
-            .failure(MyError.failed),
-            .success(2)
-        ]
-
-        // MUT
-        let res = try results.whenAllComplete(on: elg.next()) {
-            elg.future(String($0))
-        }.wait()
-
-        // validate
-        XCTAssertEqual(res.compactMap { try? $0.get() }, ["0", "2"])
-    }
-
     func test_defaultBranchVersion() throws {
         XCTAssertEqual(
             [

Tests/AppTests/IngestorTests.swift

@@ -265,7 +265,7 @@ class IngestorTests: AppTestCase {
             Package(id: UUID(), url: "https://github.com/foo/1", status: .ok, processingStage: .reconciliation),
             Package(id: UUID(), url: "https://github.com/foo/2", status: .new, processingStage: .reconciliation)
         ]
-        try await pkgs.save(on: app.db).get()
+        try await pkgs.save(on: app.db)
         let results: [Result<Joined<Package, Repository>, Error>] = [ .success(.init(model: pkgs[0])),
                                                                       .success(.init(model: pkgs[1]))]
 

Tests/AppTests/PackageTests.swift

@@ -242,18 +242,18 @@ final class PackageTests: AppTestCase {
         )
     }
 
-    func test_findSignificantReleases_old_beta() throws {
+    func test_findSignificantReleases_old_beta() async throws {
         // Test to ensure outdated betas aren't picked up as latest versions
         // setup
         let pkg = Package(id: UUID(), url: "1")
-        try pkg.save(on: app.db).wait()
-        try Repository(package: pkg, defaultBranch: "main").save(on: app.db).wait()
+        try await pkg.save(on: app.db)
+        try await Repository(package: pkg, defaultBranch: "main").save(on: app.db)
         let versions = [
             try Version(package: pkg, packageName: "foo", reference: .branch("main")),
             try Version(package: pkg, packageName: "foo", reference: .tag(2, 0, 0)),
             try Version(package: pkg, packageName: "foo", reference: .tag(2, 0, 0, "rc1"))
         ]
-        try versions.save(on: app.db).wait()
+        try await versions.save(on: app.db)
 
         // MUT
         let (release, preRelease, defaultBranch) = Package.findSignificantReleases(versions: versions, branch: "main")