Reworked AuthenticatedAction

app/controllers/AuctionsController.scala

@@ -17,9 +17,10 @@ import scala.concurrent.{ExecutionContext, Future}
 class AuctionsController @Inject()(val controllerComponents: ControllerComponents,
                                    val auctionsDAO: AuctionsDAO,
                                    val authTokensDAO: AuthTokensDAO,
+                                   authenticatedAction: AuthenticatedAction,
                                    val auctionPublisher: ActorRef[AuctionPublisher.Command],
                                    implicit val ec: ExecutionContext) extends BaseController {
-  def create = Action.andThen(AuthenticatedAction(authTokensDAO)).async(parse.json) { implicit request =>
+  def create = authenticatedAction.async(parse.json) { implicit request =>
     val auctionCreateDataResult = request.body.validate[AuctionCreateData]
     auctionCreateDataResult.fold(
       errors => Future.successful(BadRequest(JsError.toJson(errors))),

app/controllers/authentication/AuthenticatedAction.scala

@@ -5,13 +5,15 @@ import jakarta.inject.Inject
 import models.{AuthToken, User}
 import play.api.libs.json.*
 import play.api.mvc.Results.Unauthorized
-import play.api.mvc.{ActionRefiner, Request, Result, WrappedRequest}
+import play.api.mvc.{ActionBuilder, ActionRefiner, AnyContent, BodyParsers, Request, Result, WrappedRequest}
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class AuthenticatedRequest[A](val token: AuthToken, val user: User, request: Request[A]) extends WrappedRequest[A](request)
 
-class AuthenticatedAction @Inject()(authTokensDao: AuthTokensDAO)(implicit val executionContext: ExecutionContext) extends ActionRefiner[Request, AuthenticatedRequest] {
+class AuthenticatedAction @Inject()(val parser: BodyParsers.Default, authTokensDao: AuthTokensDAO)(implicit val executionContext: ExecutionContext)
+  extends ActionRefiner[Request, AuthenticatedRequest]
+  with ActionBuilder[AuthenticatedRequest, AnyContent]{
   override protected def refine[A](request: Request[A]): Future[Either[Result, AuthenticatedRequest[A]]] = {
     val authHeader = request.headers.get("Authorization")
       .map(_.split(" ", 2)(1))
@@ -35,5 +37,4 @@ class AuthenticatedAction @Inject()(authTokensDao: AuthTokensDAO)(implicit val e
       case None => unauthenticatedRequestError
     }
   }
-
 }

app/controllers/authentication/SessionsController.scala

@@ -22,7 +22,13 @@ implicit val tokenWrites: Writes[AuthToken] = (token: AuthToken) => Json.obj(
 
 
 @Singleton
-class SessionsController @Inject()(controllerComponents: ControllerComponents, usersDAO: UsersDAO, authTokensDAO: AuthTokensDAO, implicit val ec: ExecutionContext) extends AbstractController(controllerComponents) {
+class SessionsController @Inject()(
+                                    controllerComponents: ControllerComponents,
+                                    usersDAO: UsersDAO,
+                                    authTokensDAO: AuthTokensDAO,
+                                    authenticatedAction: AuthenticatedAction)
+                                  (implicit val ec: ExecutionContext)
+  extends AbstractController(controllerComponents) {
   def login() = Action.async(parse.json) { implicit request =>
     val loginDataResult = request.body.validate[LoginData]
     loginDataResult.fold(
@@ -41,7 +47,7 @@ class SessionsController @Inject()(controllerComponents: ControllerComponents, u
     )
   }
 
-  def logout = Action.andThen(new AuthenticatedAction(authTokensDAO)).async { request =>
+  def logout = authenticatedAction.async { request =>
     authTokensDAO.destroy(request.token).map{ _ => Ok("") }
   }
 }