Convert remainder of Analyze + related to a/a

Author: finestructure

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/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,

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])
     }