Convert functions to async/await

Sources/App/Management/SQLiteDatabase.swift

@@ -87,17 +87,14 @@ final class SQLiteDatabase {
         }
     }
 
-    func passwordHashForExistingPlayer(named name: PlayerName, in database: Database) -> EventLoopFuture<PasswordHash> {
-        User.query(on: database).filter(\.$name == name).first()
-            .unwrap(or: Abort(.forbidden)).map { $0.passwordHash }
-    }
+    /**
+     Change the password of a user with a recovery token
 
-    func deletePlayer(named name: PlayerName, in database: Database)  -> EventLoopFuture<Void> {
-        user(named: name, in: database).flatMap { user in
-            self.tables.leaveTable(player: user, in: database)
-        }.flatMap {
-            User.query(on: database).filter(\.$name == name).delete()
         }
+    func deletePlayer(named name: PlayerName, in database: Database) async throws {
+        let user = try await user(named: name, in: database)
+        try await tables.leaveTable(player: user, in: database)
+        try await User.query(on: database).filter(\.$name == name).delete()
     }
 
     func isValid(sessionToken token: SessionToken) -> Bool {
@@ -147,29 +144,25 @@ final class SQLiteDatabase {
         tables.tableInfo(player: player)
     }
 
-    private func points(for player: PlayerName, in database: Database) -> EventLoopFuture<Int> {
-        User.query(on: database)
+    private func points(for player: PlayerName, in database: Database) async throws -> Int {
+        try await User.query(on: database)
             .filter(\.$name == player)
             .first()
             .unwrap(or: Abort(.notFound))
-            .map { $0.points }
+            .points
     }
 
-    private func user(named name: PlayerName, in database: Database) -> EventLoopFuture<User> {
-        User.query(on: database)
+    private func user(named name: PlayerName, in database: Database) async throws -> User {
+        try await User
+            .query(on: database)
             .filter(\.$name == name)
             .first()
             .unwrap(or: Abort(.notFound))
     }
 
-    private func user(withToken token: SessionToken, in database: Database) -> EventLoopFuture<User> {
-        database.eventLoop
-            .future()
-            .map { self.playerNameForToken[token] }
-            .unwrap(or: Abort(.unauthorized))
-            .flatMap { name in
-                self.user(named: name, in: database)
-            }
+    private func user(withToken token: SessionToken, in database: Database) async throws -> User {
+        let name = try playerNameForToken[token].unwrap(or: Abort(.unauthorized))
+        return try await user(named: name, in: database)
     }
 
     // MARK: Tables
@@ -181,26 +174,23 @@ final class SQLiteDatabase {
      - Parameter isPublic: Indicates that this is a game joinable by everyone
      - Returns: The table id
      */
-    func createTable(named name: TableName, player: PlayerName, isPublic: Bool, in database: Database) -> EventLoopFuture<TableInfo> {
-        user(named: player, in: database).flatMap { player in
-            self.tables.createTable(named: name, player: player, isPublic: isPublic, in: database)
-        }
+    func createTable(named name: TableName, player: PlayerName, isPublic: Bool, in database: Database) async throws -> TableInfo {
+        let user = try await user(named: player, in: database)
+        return try await tables.createTable(named: name, player: user, isPublic: isPublic, in: database)
     }
 
     func getPublicTableInfos() -> [PublicTableInfo] {
         tables.publicTableList
     }
 
-    func join(tableId: UUID, playerToken: SessionToken, in database: Database) -> EventLoopFuture<TableInfo> {
-        user(withToken: playerToken, in: database).flatMap { player in
-            self.tables.join(tableId: tableId, player: player, in: database)
-        }
+    func join(tableId: UUID, playerToken: SessionToken, in database: Database) async throws -> TableInfo {
+        let user = try await user(withToken: playerToken, in: database)
+        return try await tables.join(tableId: tableId, player: user, in: database)
     }
 
-    func leaveTable(playerToken: SessionToken, in database: Database) -> EventLoopFuture<Void> {
-        user(withToken: playerToken, in: database).flatMap { player in
-            self.tables.leaveTable(player: player, in: database)
-        }
+    func leaveTable(playerToken: SessionToken, in database: Database) async throws {
+        let user = try await user(withToken: playerToken, in: database)
+        try await tables.leaveTable(player: user, in: database)
     }
 
     func performAction(playerToken: SessionToken, action: PlayerAction) -> PlayerActionResult {

Sources/App/Management/TableManagement.swift

@@ -38,19 +38,14 @@ final class TableManagement {
      - Parameter isPublic: Indicates that this is a game joinable by everyone
      - Returns: The table id
      */
-    func createTable(named name: TableName, player: User, isPublic: Bool, in database: Database) -> EventLoopFuture<TableInfo> {
+    func createTable(named name: TableName, player: User, isPublic: Bool, in database: Database) async throws -> TableInfo {
         let table = Table(name: name, isPublic: isPublic)
-        return table.create(on: database).flatMap {
-            player.$table.id = table.id
-            return player.update(on: database)
-        }.flatMap {
-            Table.query(on: database).with(\.$players).filter(\.$id == table.id!).first()
-        }.unwrap(or: Abort(.notFound))
-            .map { storedTable in
-            let table = WaitingTable(newTable: storedTable)
-            self.tables[table.id] = table
-            return table.tableInfo(forPlayer: player.name)
-        }
+        try await table.create(on: database)
+        player.$table.id = table.id
+        try await player.update(on: database)
+        let waitingTable = WaitingTable(newTable: table)
+        self.tables[waitingTable.id] = waitingTable
+        return waitingTable.tableInfo(forPlayer: player.name)
     }
     
     /// A list of all public tables
@@ -77,51 +72,51 @@ final class TableManagement {
      - Parameter player: The name of the player who wants to join.
      - Returns: The result of the join operation
      */
-    func join(tableId: UUID, player: User, in database: Database) -> EventLoopFuture<TableInfo> {
-        return database.eventLoop.future().flatMapThrowing { _ -> ManageableTable in
-            if let existing = self.currentTable(for: player.name) {
-                guard existing.id == tableId else {
-                    throw Abort(.forbidden) // 403
-                }
-                return existing
+    func join(tableId: UUID, player: User, in database: Database) async throws -> TableInfo {
+        let table = try joinableTable(for: player, id: tableId)
+        player.$table.id = table.id
+        try await player.update(on: database)
+        table.sendUpdateToAllPlayers()
+        return table.tableInfo(forPlayer: player.name)
+    }
+
+    private func joinableTable(for player: User, id tableId: UUID) throws -> ManageableTable {
+        if let existing = self.currentTable(for: player.name) {
+            guard existing.id == tableId else {
+                throw Abort(.forbidden) // 403
             }
-            guard let table = self.tables[tableId] else {
-                throw Abort(.gone) // 410
-            }
-            guard let joinableTable = table as? WaitingTable,
-                  joinableTable.add(player: player.name, points: player.points) else {
-                      throw Abort(.expectationFailed) // 417
-                  }
-            return joinableTable
-        }.flatMap { table -> EventLoopFuture<ManageableTable> in
-            player.$table.id = table.id
-            return player.update(on: database).map { table }
-        }.map { table in
-            table.sendUpdateToAllPlayers()
-            return table.tableInfo(forPlayer: player.name)
+            return existing
         }
+        guard let table = self.tables[tableId] else {
+            throw Abort(.gone) // 410
+        }
+        guard let joinableTable = table as? WaitingTable,
+              joinableTable.add(player: player.name, points: player.points) else {
+                  throw Abort(.expectationFailed) // 417
+              }
+        return joinableTable
     }
     
     /**
      A player leaves the table it previously joined
      - Parameter player: The player leaving the table
      */
-    func leaveTable(player: User, in database: Database) -> EventLoopFuture<Void> {
+    func leaveTable(player: User, in database: Database) async throws {
         guard let oldTable = currentTable(for: player.name) else {
-            return database.eventLoop.makeSucceededVoidFuture()
+            return
         }
         player.$table.id = nil
         guard let table = WaitingTable(oldTable: oldTable, removing: player.name) else {
             tables[oldTable.id] = nil
-            return player.update(on: database).flatMap {
-                Table.query(on: database).filter(\.$id == oldTable.id).delete()
-            }
+            try await player.update(on: database)
+            try await Table.query(on: database).filter(\.$id == oldTable.id).delete()
+            return
         }
         /// `player.canStartGame` is automatically set to false, because table is not full
         tables[table.id] = table
         table.sendUpdateToAllPlayers()
         // TODO: Update points for all players
-        return player.update(on: database)
+        try await player.update(on: database)
     }
     
     func connect(player: PlayerName, using socket: WebSocket) -> Bool {