Convert → EventLoopFuture<Void> functions to a/a

finestructure · finestructure · commit 10bdd2897b57 · 2024-08-23T13:35:24.000+02:00
diff --git a/Sources/App/Commands/Analyze.swift b/Sources/App/Commands/Analyze.swift
@@ -158,9 +158,9 @@ extension Analyze {
 
         try await RecentPackage.refresh(on: database)
         try await RecentRelease.refresh(on: database)
-        try await Search.refresh(on: database).get()
-        try await Stats.refresh(on: database).get()
-        try await WeightedKeyword.refresh(on: database).get()
+        try await Search.refresh(on: database)
+        try await Stats.refresh(on: database)
+        try await WeightedKeyword.refresh(on: database)
     }
 
 
diff --git a/Sources/App/Commands/CreateRestfile.swift b/Sources/App/Commands/CreateRestfile.swift
@@ -31,24 +31,24 @@ enum Variant: String, LosslessStringConvertible {
 }
 
 
-struct CreateRestfileCommand: Command {
+struct CreateRestfileCommand: AsyncCommand {
     struct Signature: CommandSignature {
         @Argument(name: "variant")
         var variant: Variant
     }
 
     var help: String { "Create restfile for automated testing" }
 
-    func run(using context: CommandContext, signature: Signature) throws {
+    func run(using context: CommandContext, signature: Signature) async throws {
         guard let db = context.application.db as? SQLDatabase else {
             fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")
         }
-        try createRestfile(on: db, variant: signature.variant).wait()
+        try await createRestfile(on: db, variant: signature.variant)
     }
 }
 
 
-func createRestfile(on database: SQLDatabase, variant: Variant) -> EventLoopFuture<Void> {
+func createRestfile(on database: SQLDatabase, variant: Variant) async throws {
     let mode: String
     let query: SQLQueryString
     switch variant {
@@ -96,14 +96,12 @@ func createRestfile(on database: SQLDatabase, variant: Variant) -> EventLoopFutu
     print("# auto-generated via `Run create-restfile \(variant.rawValue)`")
     print("mode: \(mode)")
     print("requests:")
-    return database.raw(query)
-        .all(decoding: Record.self)
-        .mapEach { r in
-            print("""
+    for r in try await database.raw(query).all(decoding: Record.self) {
+        print("""
                 \(r.url):
                   url: ${base_url}\(r.url)
                   validation:
                     status: .regex((2|3)\\d\\d)
               """)
-        }.transform(to: ())
+    }
 }
diff --git a/Sources/App/Commands/ReAnalyzeVersions.swift b/Sources/App/Commands/ReAnalyzeVersions.swift
@@ -88,9 +88,7 @@ enum ReAnalyzeVersions {
                 }
             }
             do {
-                try await AppMetrics.push(client: client,
-                                          jobName: "re-analyze-versions")
-                .get()
+                try await AppMetrics.push(client: client, jobName: "re-analyze-versions")
             } catch {
                 Current.logger().warning("\(error.localizedDescription)")
             }
diff --git a/Sources/App/Core/AppMetrics.swift b/Sources/App/Core/AppMetrics.swift
@@ -169,45 +169,23 @@ extension AppMetrics {
     /// a `/metrics` endpoint that could be scraped. Instead, they push to a gateway that is configured as a Prometheus
     /// scrape target.
     /// - Parameter client: client for POST request
-    /// - Returns: future
-    static func push(client: Client, jobName: String) -> EventLoopFuture<Void> {
+    static func push(client: Client, jobName: String) async throws {
         guard let pushGatewayUrl = Current.metricsPushGatewayUrl() else {
-            return client.eventLoop.future(error: AppError.envVariableNotSet("METRICS_PUSHGATEWAY_URL"))
+            throw AppError.envVariableNotSet("METRICS_PUSHGATEWAY_URL")
         }
         let url = URI(string: "\(pushGatewayUrl)/metrics/job/\(jobName)")
 
-        let promise = client.eventLoop.makePromise(of: String.self)
         do {
-            try MetricsSystem.prometheus().collect(into: promise)
+            let metrics: String = try await MetricsSystem.prometheus().collect()
+            _ = try await client.post(url) { req in
+                // append "\n" to avoid
+                //   text format parsing error in line 4: unexpected end of input stream
+                try req.content.encode(metrics + "\n")
+            }
         } catch {
-            return client.eventLoop.future(error: error)
+            Current.logger().warning("AppMetrics.push failed with error: \(error)")
+            // ignore error - we don't want metrics issues to cause upstream failures
         }
-
-        let req = promise.futureResult
-            .flatMap { metrics in
-                client.post(url) { req in
-                    // append "\n" to avoid
-                    //   text format parsing error in line 4: unexpected end of input stream
-                    try req.content.encode(metrics + "\n")
-                }
-            }
-            .transform(to: ())
-
-        return req
-            .flatMapError { error in
-                Current.logger().warning("AppMetrics.push failed with error: \(error)")
-                // absorb error - we don't want metrics issues to cause upstream failures
-                return client.eventLoop.future()
-            }
-    }
-
-
-    /// Async-await wrapper for `EventLoopFuture`-based `push`
-    /// - Parameters:
-    ///   - client: `Client`
-    ///   - jobName: job name
-    static func push(client: Client, jobName: String) async throws {
-        try await push(client: client, jobName: jobName).get()
     }
 
 }
diff --git a/Sources/App/Core/Search.swift b/Sources/App/Core/Search.swift
@@ -402,10 +402,10 @@ enum Search {
             }
     }
 
-    static func refresh(on database: Database) -> EventLoopFuture<Void> {
+    static func refresh(on database: Database) async throws {
         guard let db = database as? SQLDatabase else {
             fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")
         }
-        return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
+        try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
     }
 }
diff --git a/Sources/App/Core/Stats.swift b/Sources/App/Core/Stats.swift
@@ -28,11 +28,11 @@ struct Stats: Decodable, Equatable {
 }
 
 extension Stats {
-    static func refresh(on database: Database) -> EventLoopFuture<Void> {
+    static func refresh(on database: Database) async throws {
         guard let db = database as? SQLDatabase else {
             fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")
         }
-        return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
+        try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
     }
 
 
diff --git a/Sources/App/Models/WeightedKeyword.swift b/Sources/App/Models/WeightedKeyword.swift
@@ -48,11 +48,11 @@ extension WeightedKeyword {
             .all(decoding: Self.self)
     }
 
-    static func refresh(on database: Database) -> EventLoopFuture<Void> {
+    static func refresh(on database: Database) async throws {
         guard let db = database as? SQLDatabase else {
             fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")
         }
-        return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
+        try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()
     }
 }
 
diff --git a/Tests/AppTests/ApiTests.swift b/Tests/AppTests/ApiTests.swift
@@ -64,7 +64,7 @@ class ApiTests: AppTestCase {
                              summary: "foo bar package").save(on: app.db)
         try await Version(package: p1, packageName: "Foo", reference: .branch("main")).save(on: app.db)
         try await Version(package: p2, packageName: "Bar", reference: .branch("main")).save(on: app.db)
-        try await Search.refresh(on: app.db).get()
+        try await Search.refresh(on: app.db)
 
         let event = ActorIsolated<TestEvent?>(nil)
         Current.postPlausibleEvent = { @Sendable _, kind, path, _ in
@@ -805,7 +805,7 @@ class ApiTests: AppTestCase {
         try await v.save(on: app.db)
         try await Product(version: v, type: .library(.automatic), name: "lib")
             .save(on: app.db)
-        try await Search.refresh(on: app.db).get()
+        try await Search.refresh(on: app.db)
 
         let event = ActorIsolated<TestEvent?>(nil)
         Current.postPlausibleEvent = { @Sendable _, kind, path, _ in
@@ -850,47 +850,47 @@ class ApiTests: AppTestCase {
         }
     }
 
-    func test_package_collections_packageURLs() throws {
+    func test_package_collections_packageURLs() async throws {
         try XCTSkipIf(!isRunningInCI && Current.collectionSigningPrivateKey() == nil, "Skip test for local user due to unset COLLECTION_SIGNING_PRIVATE_KEY env variable")
         // setup
         let refDate = Date(timeIntervalSince1970: 0)
         Current.date = { refDate }
         Current.apiSigningKey = { "secret" }
         let p1 = Package(id: UUID(uuidString: "442cf59f-0135-4d08-be00-bc9a7cebabd3")!,
                          url: "1")
-        try p1.save(on: app.db).wait()
+        try await p1.save(on: app.db)
         let p2 = Package(id: UUID(uuidString: "4e256250-d1ea-4cdd-9fe9-0fc5dce17a80")!,
                          url: "2")
-        try p2.save(on: app.db).wait()
-        try Repository(package: p1,
-                       defaultBranch: "main",
-                       summary: "some package").save(on: app.db).wait()
-        try Repository(package: p2,
-                       defaultBranch: "main",
-                       name: "name 2",
-                       owner: "foo",
-                       summary: "foo bar package").save(on: app.db).wait()
+        try await p2.save(on: app.db)
+        try await Repository(package: p1,
+                             defaultBranch: "main",
+                             summary: "some package").save(on: app.db)
+        try await Repository(package: p2,
+                             defaultBranch: "main",
+                             name: "name 2",
+                             owner: "foo",
+                             summary: "foo bar package").save(on: app.db)
         do {
             let v = try Version(package: p1,
                                 latest: .release,
                                 packageName: "Foo",
                                 reference: .tag(1, 2, 3),
                                 toolsVersion: "5.3")
-            try v.save(on: app.db).wait()
-            try Product(version: v, type: .library(.automatic), name: "p1")
-                .save(on: app.db).wait()
+            try await v.save(on: app.db)
+            try await Product(version: v, type: .library(.automatic), name: "p1")
+                .save(on: app.db)
         }
         do {
             let v = try Version(package: p2,
                                 latest: .release,
                                 packageName: "Bar",
                                 reference: .tag(2, 0, 0),
                                 toolsVersion: "5.4")
-            try v.save(on: app.db).wait()
-            try Product(version: v, type: .library(.automatic), name: "p2")
-                .save(on: app.db).wait()
+            try await v.save(on: app.db)
+            try await Product(version: v, type: .library(.automatic), name: "p2")
+                .save(on: app.db)
         }
-        try Search.refresh(on: app.db).wait()
+        try await Search.refresh(on: app.db)
 
         do {  // MUT
             let body: ByteBuffer = .init(string: """
@@ -913,16 +913,16 @@ class ApiTests: AppTestCase {
                 }
                 """)
 
-            try app.test(.POST,
-                         "api/package-collections",
-                         headers: .bearerApplicationJSON((try .apiToken(secretKey: "secret", tier: .tier3))),
-                         body: body,
-                         afterResponse: { res in
-                            // validation
-                            XCTAssertEqual(res.status, .ok)
-                            let pkgColl = try res.content.decode(PackageCollection.self)
-                            assertSnapshot(of: pkgColl, as: .dump)
-                        })
+            try await app.test(.POST,
+                               "api/package-collections",
+                               headers: .bearerApplicationJSON((try .apiToken(secretKey: "secret", tier: .tier3))),
+                               body: body,
+                               afterResponse: { res async throws in
+                // validation
+                XCTAssertEqual(res.status, .ok)
+                let pkgColl = try res.content.decode(PackageCollection.self)
+                assertSnapshot(of: pkgColl, as: .dump)
+            })
         }
     }
 
diff --git a/Tests/AppTests/SearchTests.swift b/Tests/AppTests/SearchTests.swift
diff --git a/Tests/AppTests/SitemapTests.swift b/Tests/AppTests/SitemapTests.swift
diff --git a/Tests/AppTests/StatsTests.swift b/Tests/AppTests/StatsTests.swift
diff --git a/Tests/AppTests/Util.swift b/Tests/AppTests/Util.swift

Original file line number	Diff line number	Diff line change
`@@ -88,9 +88,7 @@ enum ReAnalyzeVersions {`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`do {`
`91`		`- try await AppMetrics.push(client: client,`
`92`		`- jobName: "re-analyze-versions")`
`93`		`- .get()`
	`91`	`+ try await AppMetrics.push(client: client, jobName: "re-analyze-versions")`
`94`	`92`	`} catch {`
`95`	`93`	`Current.logger().warning("\(error.localizedDescription)")`
`96`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -402,10 +402,10 @@ enum Search {`
`402`	`402`	`}`
`403`	`403`	`}`
`404`	`404`
`405`		`- static func refresh(on database: Database) -> EventLoopFuture<Void> {`
	`405`	`+ static func refresh(on database: Database) async throws {`
`406`	`406`	`guard let db = database as? SQLDatabase else {`
`407`	`407`	`fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")`
`408`	`408`	`}`
`409`		`- return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
	`409`	`+ try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
`410`	`410`	`}`
`411`	`411`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,11 @@ struct Stats: Decodable, Equatable {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`extension Stats {`
`31`		`- static func refresh(on database: Database) -> EventLoopFuture<Void> {`
	`31`	`+ static func refresh(on database: Database) async throws {`
`32`	`32`	`guard let db = database as? SQLDatabase else {`
`33`	`33`	`fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")`
`34`	`34`	`}`
`35`		`- return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
	`35`	`+ try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
`36`	`36`	`}`
`37`	`37`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -48,11 +48,11 @@ extension WeightedKeyword {`
`48`	`48`	`.all(decoding: Self.self)`
`49`	`49`	`}`
`50`	`50`
`51`		`- static func refresh(on database: Database) -> EventLoopFuture<Void> {`
	`51`	`+ static func refresh(on database: Database) async throws {`
`52`	`52`	`guard let db = database as? SQLDatabase else {`
`53`	`53`	`fatalError("Database must be an SQLDatabase ('as? SQLDatabase' must succeed)")`
`54`	`54`	`}`
`55`		`- return db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
	`55`	`+ try await db.raw("REFRESH MATERIALIZED VIEW \(ident: Self.schema)").run()`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`