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

Author: jdegoes

build.sbt

@@ -48,7 +48,6 @@ 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 --
@@ -62,25 +61,20 @@ libraryDependencies ++= Seq(
   "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
 )

src/main/resources/application.conf

@@ -4,7 +4,7 @@ api {
 }
 
 db-config {
-  url = "jdbc:h2:~/test;DB_CLOSE_DELAY=-1"
+  url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1"
   user = ""
   password = ""
 }

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

@@ -2,4 +2,4 @@ package net.degoes.applications.data
 
 final case class User(id: Long, name: String)
 
-final case class UserNotFound(id: Int) extends Exception
+final case class UserNotFound(id: Int) extends Exception

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

@@ -1,9 +1,12 @@
+/**
+ * This example is inspired by [[https://github.com/mschuwalow/zio-todo-backend]]
+ */
 package net.degoes.applications
 
 import cats.effect.ExitCode
+import net.degoes.applications.configuration.Configuration
 import net.degoes.applications.db.Persistence
 import net.degoes.applications.http.Api
-import net.degoes.applications.configuration._
 import org.http4s.implicits._
 import org.http4s.server.Router
 import org.http4s.server.blaze.BlazeServerBuilder
@@ -16,19 +19,16 @@ import scalaz.zio.{ Task, TaskR, ZIO, _ }
 
 object Main extends App {
 
-  type AppEnvironment = Clock with Blocking with Persistence
+  type AppEnvironment = Clock 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)
+      conf        <- configuration.load.provide(Configuration.Live)
+      blockingEC  <- blocking.blockingExecutor.map(_.asEC).provide(Blocking.Live)
 
-      blockingEnv <- ZIO.environment[Blocking]
-      blockingEC  <- blockingEnv.blocking.blockingExecutor.map(_.asEC)
-
-      transactorR = configuration.mkTransactor(
+      transactorR = Persistence.mkTransactor(
         conf.dbConfig,
         Platform.executor.asEC,
         blockingEC
@@ -39,16 +39,17 @@ object Main extends App {
       ).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
+        db.createTable *>
+          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 {
+                    new Clock.Live with Persistence.Live {
                       override protected def tnx: doobie.Transactor[Task] = transactor
                     }
                   }

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

@@ -1,4 +1,7 @@
 package net.degoes.applications.configuration
+import pureconfig.loadConfigOrThrow
+import scalaz.zio.{ Task, TaskR }
+import pureconfig.generic.auto._
 
 case class Config(api: ApiConfig, dbConfig: DbConfig)
 case class ApiConfig(endpoint: String, port: Int)
@@ -7,3 +10,22 @@ case class DbConfig(
   user: String,
   password: String
 )
+
+trait Configuration extends Serializable {
+  val config: Configuration.Service[Any]
+}
+
+object Configuration {
+  trait Service[R] {
+    val load: TaskR[R, Config]
+  }
+
+  trait Live extends Configuration {
+    val config: Service[Any] = new Service[Any] {
+      val load: Task[Config] = Task.effect(loadConfigOrThrow[Config])
+    }
+  }
+
+
+  object Live extends Live
+}

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

@@ -1,38 +1,7 @@
 package net.degoes.applications
 
-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._
+import scalaz.zio.TaskR
 
-package object configuration {
-  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)
-  }
-}
+package object configuration extends Configuration.Service[Configuration] {
+  val load: TaskR[Configuration, Config] = TaskR.accessM(_.config.load)
+}

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

@@ -1,10 +1,13 @@
 package net.degoes.applications.db
 
-import net.degoes.applications.data.{ User, UserNotFound }
+import doobie.h2.H2Transactor
+import doobie.implicits._
 import doobie.{ Query0, Transactor, Update0 }
+import net.degoes.applications.configuration.DbConfig
+import net.degoes.applications.data.{ User, UserNotFound }
+import scala.concurrent.ExecutionContext
 import scalaz.zio._
-import doobie.implicits._
-import scalaz.zio.interop.catz._
+import scalaz.zio.interop.catz.taskConcurrentInstances
 
 /**
  * Persistence Service
@@ -14,7 +17,9 @@ trait Persistence extends Serializable {
 }
 
 object Persistence {
+
   trait Service[R] {
+    val createTable: TaskR[R, Unit]
     def get(id: Int): TaskR[R, User]
     def create(user: User): TaskR[R, User]
     def delete(id: Int): TaskR[R, Unit]
@@ -29,13 +34,16 @@ object Persistence {
 
     val userPersistence: Service[Any] = new Service[Any] {
 
+      val createTable: Task[Unit] =
+        SQL.createTable.run.transact(tnx).foldM(err => Task.fail(err), _ => Task.succeed(()))
+
       def get(id: Int): Task[User] =
         SQL
           .get(id)
           .option
           .transact(tnx)
           .foldM(
-            err => Task.fail(err),
+            Task.fail,
             maybeUser => Task.require(UserNotFound(id))(Task.succeed(maybeUser))
           )
 
@@ -51,20 +59,47 @@ object Persistence {
           .delete(id)
           .run
           .transact(tnx)
-          .foldM(err => Task.fail(err), _ => Task.succeed(()))
+          .unit
+          .orDie
     }
 
     object SQL {
 
+      def createTable: Update0 = sql"""CREATE TABLE IF NOT EXISTS Users (id int PRIMARY KEY, name varchar)""".update
+
       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
+        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
+        sql"""DELETE FROM USERS WHERE ID = $id""".update
     }
+
   }
+  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)
+  }
+
+  /**
+   * Persistence Module for test
+   */
+  case class Test(users: Ref[Vector[User]]) extends Persistence {
+    override val userPersistence: Service[Any] = ???
+  }
 }

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

@@ -7,7 +7,7 @@ import scalaz.zio.{ TaskR, ZIO }
  * Helper that will access to the Persistence Service
  */
 package object db extends Persistence.Service[Persistence] {
-
+  val createTable: TaskR[Persistence, Unit]        = ZIO.accessM(_.userPersistence.createTable)
   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

@@ -1,15 +1,14 @@
 package net.degoes.applications.http
 
+import io.circe.generic.auto._
+import io.circe.{Decoder, Encoder}
 import net.degoes.applications.data.User
-import net.degoes.applications.db._
-import net.degoes.applications.db.Persistence
-import io.circe.{ Decoder, Encoder }
-import org.http4s.{ EntityDecoder, EntityEncoder, HttpRoutes }
+import net.degoes.applications.db.{Persistence, _}
+import org.http4s.circe._
 import org.http4s.dsl.Http4sDsl
+import org.http4s.{EntityDecoder, EntityEncoder, HttpRoutes}
 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) {
 
@@ -30,7 +29,7 @@ final case class Api[R <: Persistence](rootUri: String) {
           Created(create(user))
         }
       case DELETE -> Root / IntVar(id) =>
-        delete(id).foldM(_ => NotFound(), Ok(_))
+        (get(id) *> delete(id)).foldM(_ => NotFound(), Ok(_))
     }
 
 }

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

@@ -1,4 +1,4 @@
-package example.db
+package net.degoes.applications
 
 import java.util.{Timer, TimerTask}
 import org.specs2.Specification
@@ -32,7 +32,7 @@ abstract class TestRuntime extends Specification with DefaultRuntime {
     }
     timer.schedule(task, timeout.toMillis)
 
-    unsafeRunToFuture(zio.sandbox.mapError(FiberFailure).map(p.success))
+    unsafeRunToFuture(zio.sandbox.mapError(FiberFailure).map(p.success).supervised)
     p.future
   }
 

src/test/scala/06-application/configuration/ConfigurationSpec.scala

@@ -0,0 +1,17 @@
+package net.degoes.applications.configuration
+import net.degoes.applications.TestRuntime
+
+final class ConfigurationSpec extends TestRuntime {
+
+  def is =
+    s2"""
+        Configuration.Live should work correctly $e
+      """
+
+  def e =
+    load.provide(Configuration.Live).map { config =>
+      config.api must_=== ApiConfig("127.0.0.1", 8080)
+      config.dbConfig must_=== DbConfig("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1", "", "")
+    }
+
+}