Merge branch 'master' of github.com:jdegoes/functional-scala

Author: jdegoes

build.sbt

@@ -22,34 +22,72 @@ scalaVersion := "2.12.6"
 addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.6")
 
 scalacOptions ++= Seq(
-  "-deprecation"
-  , "-unchecked"
-  , "-encoding", "UTF-8"
-  , "-Xlint"
-  , "-Xverify"
-  , "-feature"
-  , "-Ypartial-unification"
-  , "-Xlint:-unused"
-  , "-language:_"
+  "-deprecation",
+  "-unchecked",
+  "-encoding",
+  "UTF-8",
+  "-Xlint",
+  "-Xverify",
+  "-feature",
+  "-Ypartial-unification",
+  "-Xlint:-unused",
+  "-language:_"
 )
 
-javacOptions ++= Seq("-Xlint:unchecked", "-Xlint:deprecation", "-source", "1.7", "-target", "1.7")
+javacOptions ++= Seq("-Xlint:unchecked",
+                     "-Xlint:deprecation",
+                     "-source",
+                     "1.7",
+                     "-target",
+                     "1.7")
 
-val ScalaZVersion     = "7.2.26"
+val ScalaZVersion = "7.2.26"
+val Http4sVersion = "0.20.1"
+val CirceVersion = "0.12.0-M1"
+val DoobieVersion = "0.7.0-M5"
+val ZIOVersion = "1.0-RC4"
+val PureConfigVersion = "0.11.0"
+val H2Version = "1.4.199"
+val FlywayVersion = "6.0.0-beta2"
 
 libraryDependencies ++= Seq(
   // -- testing --
-  "org.scalacheck"  %% "scalacheck"         % "1.13.4"  % "test",
-  "org.scalatest"   %% "scalatest"          % "3.0.1"   % "test",
+  "org.scalacheck" %% "scalacheck" % "1.13.4" % "test",
+  "org.scalatest" %% "scalatest" % "3.0.1" % "test",
+  "org.specs2" %% "specs2-core" % "4.3.2" % "test",
   // Scalaz
-  "org.scalaz"      %% "scalaz-core"        % ScalaZVersion,
+  "org.scalaz" %% "scalaz-core" % ScalaZVersion,
+  // ZIO
+  "org.scalaz" %% "scalaz-zio" % ZIOVersion,
+  "org.scalaz" %% "scalaz-zio-interop-cats" % ZIOVersion,
+  // Http4s
+  "org.http4s" %% "http4s-blaze-server" % Http4sVersion,
+  "org.http4s" %% "http4s-blaze-client" % Http4sVersion,
+  "org.http4s" %% "http4s-circe" % Http4sVersion,
+  "org.http4s" %% "http4s-dsl" % Http4sVersion,
+  // Circe
+  "io.circe" %% "circe-generic" % CirceVersion,
+  "io.circe" %% "circe-generic-extras" % CirceVersion,
+  // Doobie
+  "org.tpolecat" %% "doobie-core" % DoobieVersion,
+  "org.tpolecat" %% "doobie-h2" % DoobieVersion,
+  "org.tpolecat" %% "doobie-hikari" % DoobieVersion,
+  "org.tpolecat" %% "doobie-h2"     % DoobieVersion,
+  // log4j
+  "org.slf4j" % "slf4j-log4j12" % "1.7.26",
+  //pure config
+  "com.github.pureconfig" %% "pureconfig" % PureConfigVersion,
+  //h2
+  "com.h2database" % "h2" % H2Version,
+  //flyway
+  "org.flywaydb" %  "flyway-core" % FlywayVersion,
   // Ammonite
-  "com.lihaoyi"     %  "ammonite"           % "1.1.2"   % "test" cross CrossVersion.full
+  "com.lihaoyi" % "ammonite" % "1.1.2" % "test" cross CrossVersion.full
 )
 
 resolvers ++= Seq(
-  "Typesafe Snapshots"          at "http://repo.typesafe.com/typesafe/snapshots/",
-  "Secured Central Repository"  at "https://repo1.maven.org/maven2",
+  "Typesafe Snapshots" at "http://repo.typesafe.com/typesafe/snapshots/",
+  "Secured Central Repository" at "https://repo1.maven.org/maven2",
   Resolver.sonatypeRepo("snapshots")
 )
 

src/main/resources/application.conf

@@ -0,0 +1,10 @@
+api {
+  endpoint = "127.0.0.1"
+  port = 8080
+}
+
+db-config {
+  url = "jdbc:h2:~/test;DB_CLOSE_DELAY=-1"
+  user = ""
+  password = ""
+}

src/main/resources/log4j.properties

@@ -0,0 +1,5 @@
+log4j.rootLogger=INFO, console
+
+log4j.appender.console=org.apache.log4j.ConsoleAppender
+log4j.appender.console.layout=org.apache.log4j.EnhancedPatternLayout
+log4j.appender.console.layout.ConversionPattern=[%-t] %-15c{1.}: %m%n

src/main/scala/net/degoes/06-application/Data.scala

@@ -0,0 +1,5 @@
+package data
+
+final case class User(id: Long, name: String)
+
+final case class UserNotFound(id: Int) extends Exception

src/main/scala/net/degoes/06-application/Main.scala

@@ -0,0 +1,61 @@
+import cats.effect.ExitCode
+import db.Persistence
+import http.Api
+import org.http4s.implicits._
+import org.http4s.server.Router
+import org.http4s.server.blaze.BlazeServerBuilder
+import org.http4s.server.middleware.CORS
+import scalaz.zio.blocking.Blocking
+import scalaz.zio.clock.Clock
+import scalaz.zio.console.putStrLn
+import scalaz.zio.interop.catz._
+import scalaz.zio.{Task, TaskR, ZIO, _}
+
+object Main extends App {
+
+  type AppEnvironment = Clock with Blocking with Persistence
+
+  type AppTask[A] = TaskR[AppEnvironment, A]
+
+  override def run(args: List[String]): ZIO[Environment, Nothing, Int] = {
+    val program: ZIO[Main.Environment, Throwable, Unit] = for {
+      conf <- configuration.loadConfig
+      _ <- configuration.initDB(conf.dbConfig)
+
+      blockingEnv <- ZIO.environment[Blocking]
+      blockingEC <- blockingEnv.blocking.blockingExecutor.map(_.asEC)
+
+      transactorR = configuration.mkTransactor(
+        conf.dbConfig,
+        Platform.executor.asEC,
+        blockingEC
+      )
+
+      httpApp = Router[AppTask](
+        "/users" -> Api(s"${conf.api.endpoint}/users").route
+      ).orNotFound
+
+      server = ZIO.runtime[AppEnvironment].flatMap { implicit rts =>
+        BlazeServerBuilder[AppTask]
+          .bindHttp(conf.api.port, "0.0.0.0")
+          .withHttpApp(CORS(httpApp))
+          .serve
+          .compile[AppTask, AppTask, ExitCode]
+          .drain
+      }
+      program <- transactorR.use { transactor =>
+        server.provideSome[Environment] { _ =>
+          new Clock.Live with Blocking.Live
+          with Persistence.Live {
+            override protected def tnx: doobie.Transactor[Task] = transactor
+          }
+        }
+      }
+    } yield program
+
+    program.foldM(
+      err => putStrLn(s"Execution failed with: $err") *> IO.succeed(1),
+      _ => IO.succeed(0)
+    )
+  }
+}

src/main/scala/net/degoes/06-application/configuration/package.scala

@@ -0,0 +1,46 @@
+import doobie.h2.H2Transactor
+import org.flywaydb.core.Flyway
+import pureconfig.loadConfigOrThrow
+import scala.concurrent.ExecutionContext
+import scalaz.zio.{Managed, Reservation, Task, ZIO}
+import pureconfig.generic.auto._
+
+package object configuration {
+
+  case class Config(api: ApiConfig, dbConfig: DbConfig)
+  case class ApiConfig(endpoint: String, port: Int)
+  case class DbConfig(
+      url: String,
+      user: String,
+      password: String
+  )
+
+  def loadConfig: Task[Config] = Task.effect(loadConfigOrThrow[Config])
+  def initDB(conf: DbConfig): Task[Unit] =
+    Task.effect {
+      Flyway
+        .configure()
+        .dataSource(conf.url, conf.user, conf.password)
+        .load()
+        .migrate()
+    }.unit
+
+  def mkTransactor(
+      conf: DbConfig,
+      connectEC: ExecutionContext,
+      transactEC: ExecutionContext
+  ): Managed[Throwable, H2Transactor[Task]] = {
+    import scalaz.zio.interop.catz._
+
+    val xa = H2Transactor
+      .newH2Transactor[Task](conf.url, conf.user, conf.password, connectEC, transactEC)
+
+    val res = xa.allocated.map {
+      case (transactor, cleanupM) =>
+        Reservation(ZIO.succeed(transactor), cleanupM.orDie)
+    }.uninterruptible
+
+    Managed(res)
+  }
+
+}

src/main/scala/net/degoes/06-application/db/Persistence.scala

@@ -0,0 +1,70 @@
+package db
+
+import data.{ User, UserNotFound }
+import doobie.{ Query0, Transactor, Update0 }
+import scalaz.zio._
+import doobie.implicits._
+import scalaz.zio.interop.catz._
+
+/**
+ * Persistence Service
+ */
+trait Persistence extends Serializable {
+  val userPersistence: Persistence.Service[Any]
+}
+
+object Persistence {
+  trait Service[R] {
+    def get(id: Int): TaskR[R, User]
+    def create(user: User): TaskR[R, User]
+    def delete(id: Int): TaskR[R, Unit]
+  }
+
+  /**
+   * Persistence Module for production using Doobie
+   */
+  trait Live extends Persistence {
+
+    protected def tnx: Transactor[Task]
+
+    val userPersistence: Service[Any] = new Service[Any] {
+
+      def get(id: Int): Task[User] =
+        SQL
+          .get(id)
+          .option
+          .transact(tnx)
+          .foldM(
+            err => Task.fail(err),
+            maybeUser => Task.require(UserNotFound(id))(Task.succeed(maybeUser))
+          )
+
+      def create(user: User): Task[User] =
+        SQL
+          .create(user)
+          .run
+          .transact(tnx)
+          .foldM(err => Task.fail(err), _ => Task.succeed(user))
+
+      def delete(id: Int): Task[Unit] =
+        SQL
+          .delete(id)
+          .run
+          .transact(tnx)
+        .foldM(err => Task.fail(err), _ => Task.succeed(()))
+    }
+
+    object SQL {
+
+      def get(id: Int): Query0[User] =
+        sql"""SELECT * FROM USERS WHERE ID = $id """.query[User]
+
+      def create(user: User): Update0 =
+        sql"""INSERT INTO USERS (id, name) VALUES (${user.id}, ${user.name})""".update
+
+      def delete(id: Int): Update0 =
+        sql"""DELETE FROM USERS WHERE id = $id""".update
+    }
+  }
+
+}

src/main/scala/net/degoes/06-application/db/package.scala

@@ -0,0 +1,12 @@
+import data.User
+import scalaz.zio.{TaskR, ZIO}
+
+/**
+  * Helper that will access to the Persistence Service
+  */
+package object db extends Persistence.Service[Persistence] {
+
+  def get(id: Int): TaskR[Persistence, User] = ZIO.accessM(_.userPersistence.get(id))
+  def create(user: User): TaskR[Persistence, User] = ZIO.accessM(_.userPersistence.create(user))
+  def delete(id: Int): TaskR[Persistence, Unit] = ZIO.accessM(_.userPersistence.delete(id))
+}

src/main/scala/net/degoes/06-application/http/Api.scala

@@ -0,0 +1,36 @@
+package http
+
+import data.User
+import db._
+import db.Persistence
+import io.circe.{ Decoder, Encoder }
+import org.http4s.{ EntityDecoder, EntityEncoder, HttpRoutes }
+import org.http4s.dsl.Http4sDsl
+import scalaz.zio._
+import org.http4s.circe._
+import scalaz.zio.interop.catz._
+import io.circe.generic.auto._
+
+final case class Api[R <: Persistence](rootUri: String) {
+
+  type UserTask[A] = TaskR[R, A]
+
+  implicit def circeJsonDecoder[A](implicit decoder: Decoder[A]): EntityDecoder[UserTask, A] = jsonOf[UserTask, A]
+  implicit def circeJsonEncoder[A](implicit decoder: Encoder[A]): EntityEncoder[UserTask, A] =
+    jsonEncoderOf[UserTask, A]
+
+  val dsl: Http4sDsl[UserTask] = Http4sDsl[UserTask]
+  import dsl._
+
+  def route: HttpRoutes[UserTask] =
+    HttpRoutes.of[UserTask] {
+      case GET -> Root / IntVar(id) => get(id).foldM(_ => NotFound(), Ok(_))
+      case request @ POST -> Root =>
+        request.decode[User] { user =>
+          Created(create(user))
+        }
+      case DELETE -> Root / IntVar(id) =>
+        delete(id).foldM(_ => NotFound(), Ok(_))
+    }
+
+}

src/test/resources/log4j.properties

@@ -0,0 +1,5 @@
+log4j.rootLogger=INFO, console
+
+log4j.appender.console=org.apache.log4j.ConsoleAppender
+log4j.appender.console.layout=org.apache.log4j.EnhancedPatternLayout
+log4j.appender.console.layout.ConversionPattern=[%-t] %-15c{1.}: %m%n

src/test/scala/06-application/TestRuntime.scala

@@ -0,0 +1,40 @@
+package example.db
+
+import java.util.{Timer, TimerTask}
+import org.specs2.Specification
+import org.specs2.execute.AsResult
+import org.specs2.specification.core.{AsExecution, Execution}
+import scala.concurrent.duration._
+import scala.concurrent.{ExecutionContext, Future}
+import scalaz.zio._
+
+abstract class TestRuntime extends Specification with DefaultRuntime {
+  val DefaultTimeout: Duration      = 60.seconds
+  val timer                         = new Timer()
+  implicit val ec: ExecutionContext = ExecutionContext.Implicits.global
+
+  implicit def zioAsExecution[A: AsResult, R >: Environment, E]: AsExecution[ZIO[R, E, A]] =
+    zio => Execution.withEnvAsync(_ => runToFutureWithTimeout(zio, DefaultTimeout))
+
+  protected def runToFutureWithTimeout[E, R >: Environment, A: AsResult](
+    zio: ZIO[R, E, A],
+    timeout: Duration
+  ): Future[A] = {
+    val p = scala.concurrent.Promise[A]()
+    val task = new TimerTask {
+      override def run(): Unit =
+        try {
+          p.failure(new Exception("TIMEOUT: " + timeout))
+          ()
+        } catch {
+          case _: Throwable => ()
+        }
+    }
+    timer.schedule(task, timeout.toMillis)
+
+    unsafeRunToFuture(zio.sandbox.mapError(FiberFailure).map(p.success))
+    p.future
+  }
+
+
+}