1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.technical.directives
21 
22 import cats.Monad
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import org.make.core.{ValidationError, ValidationFailedError}
26 
27 import scala.concurrent.Future
28 import scala.util.{Failure, Success}
29 
30 object FutureDirectivesExtensions extends Directives {
31 
32   implicit class FutureWithRoutes[T](f: Future[T]) {
33 
34     def asDirective: Directive1[T] =
35       extract(_ => f).flatMap { fa =>
36         onComplete(fa).flatMap {
37           case Success(value) => provide(value)
38           case Failure(e)     => failWith(e)
39         }
40       }
41   }
42 
43   implicit class FutureOptionWithRoutes[T](f: Future[Option[T]]) {
44 
45     def asDirectiveOrNotFound: Directive1[T] =
46       f.asDirective.flatMap {
47         case Some(value) => provide(value)
48         case None        => complete(StatusCodes.NotFound)
49       }
50 
51     def asDirectiveOrBadRequest(err: ValidationError): Directive1[T] =
52       f.asDirective.flatMap {
53         case Some(value) => provide(value)
54         case None        => failWith(ValidationFailedError(Seq(err)))
55       }
56   }
57 
58   implicit val directive1Monad: Monad[Directive1] = new Monad[Directive1] {
59 
60     override def pure[A](x: A): Directive1[A] = provide(x)
61 
62     override def flatMap[A, B](fa: Directive1[A])(f: A => Directive1[B]): Directive1[B] =
63       fa.flatMap(f)
64 
65     // This method implementation isn't actually tail-recursive because we were unable to make it
66     // so. That completely ruins the point of this method even existing, but it is required, and we
67     // figured a flawed implementation would be better than no implementation (`???`).
68     @SuppressWarnings(Array("org.wartremover.warts.Recursion"))
69     override def tailRecM[A, B](a: A)(f: A => Directive1[Either[A, B]]): Directive1[B] = {
70       f(a).flatMap {
71         _.fold(tailRecM(_)(f), pure)
72       }
73     }
74   }
75 }