Adding play-sql module (#15)

* Re-ordering module namespace + adding play-sql module

* Fix Play resource loaner to handle explicitly commit and rollback case

* WIP: add spec for WithPlayTransaction component

* add tests specs for WithPlayTransaction component

* Cleaning + add test case

* Instanciate connection as a lazy val

* Refactor: rename test + clean db after each text

* Fixing tests + replacing H2 by an embedded postgresql

* Fixing spec formatting

* Reverting gitignore

* Cleaning conf file

* wip: Refactor ComposeWithCompletion

* Refactor: composition on Future effect + WithPlayTransaction error handlng

* Cleaning and refactoring test

* Fix: formatting

* Cleaning

Author: stankoua

build.sbt

@@ -59,7 +59,11 @@ scalafmtConfig in ThisBuild := file("project/scalafmt.conf")
 
 wartremoverErrors ++= Warts.unsafe
 
+//
 // Projects definitions
+//
+
+// Core + Modules
 
 lazy val core = (project in file("core"))
   .settings(
@@ -74,20 +78,41 @@ lazy val core = (project in file("core"))
     )
   )
 
+lazy val playSqlModule = (project in file("modules/play-sql"))
+  .settings(commonSettings)
+  .settings(
+    name := "query-play-sql",
+    libraryDependencies ++= Seq(
+      jdbc,
+      evolutions               % Test,
+      logback                  % Test,
+      Dependencies.acolyte     % Test,
+      Dependencies.acolytePlay % Test,
+      Dependencies.anorm       % Test,
+      Dependencies.h2          % Test,
+      Dependencies.scalaLogging,
+      Dependencies.specs2 % Test
+    )
+  )
+  .dependsOn(core % "test->test;compile->compile")
+
+// Examples
+
 lazy val sampleAppExample = (project in file("examples/sample-app"))
   .enablePlugins(PlayScala)
   .settings(
     commonSettings ++ Seq(
       name := "sample-app-example",
       libraryDependencies ++= Seq(
-        jdbc,
         Dependencies.anorm,
         Dependencies.h2
       )
     )
   )
-  .dependsOn(core)
+  .dependsOn(core, playSqlModule)
+
+// Aggregate all projects
 
 lazy val root: Project = project
   .in(file("."))
-  .aggregate(core, sampleAppExample)
+  .aggregate(core, sampleAppExample, playSqlModule)

core/src/main/scala/core/database/ComposeWithCompletion.scala

@@ -7,27 +7,23 @@ import scala.language.higherKinds
  * Heavily inspired from work done by @cchantep in Acolyte (see acolyte.reactivemongo.ComposeWithCompletion)
  */
 trait ComposeWithCompletion[F[_], Out] {
-  type Outer <: Future[_]
+  type Outer
 
-  def apply[In](resource: In, f: In => F[Out])(onComplete: In => Unit)(
-      implicit ec: ExecutionContext
-  ): Outer
+  def apply[In](loaner: WithResource[In], f: In => F[Out]): Future[Outer]
 }
 
 object ComposeWithCompletion extends LowPriorityCompose {
 
-  type Aux[F[_], A, B] = ComposeWithCompletion[F, A] { type Outer = Future[B] }
+  type Aux[F[_], A, B] = ComposeWithCompletion[F, A] { type Outer = B }
 
   implicit def futureOut[A]: Aux[Future, A, A] =
     new ComposeWithCompletion[Future, A] {
-      type Outer = Future[A]
+      type Outer = A
 
-      def apply[In](resource: In, f: In => Future[A])(
-          onComplete: In => Unit
-      )(implicit ec: ExecutionContext): Outer =
-        f(resource).andThen {
-          case _ => onComplete(resource)
-        }
+      def apply[In](
+          loaner: WithResource[In],
+          f: In => Future[A]
+      ): Future[Outer] = loaner(f)
 
       override val toString = "futureOut"
     }
@@ -36,14 +32,14 @@ object ComposeWithCompletion extends LowPriorityCompose {
 
 trait LowPriorityCompose { _: ComposeWithCompletion.type =>
 
-  implicit def pureOut[F[_], A]: Aux[F, A, F[A]] =
+  implicit def pureOut[F[_], A](
+      implicit ec: ExecutionContext
+  ): Aux[F, A, F[A]] =
     new ComposeWithCompletion[F, A] {
-      type Outer = Future[F[A]]
+      type Outer = F[A]
 
-      def apply[In](resource: In, f: In => F[A])(
-          onComplete: In => Unit
-      )(implicit ec: ExecutionContext): Outer =
-        Future(f(resource)).andThen { case _ => onComplete(resource) }
+      def apply[In](loaner: WithResource[In], f: In => F[A]): Future[Outer] =
+        loaner(r => Future(f(r)))
 
       override val toString = "pureOut"
     }

core/src/main/scala/core/database/QueryRunner.scala

@@ -1,6 +1,6 @@
 package com.zengularity.querymonad.core.database
 
-import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
 import scala.language.higherKinds
 
 /**
@@ -9,27 +9,21 @@ import scala.language.higherKinds
 sealed trait QueryRunner[Resource] {
   def apply[M[_], T](query: QueryT[M, Resource, T])(
       implicit compose: ComposeWithCompletion[M, T]
-  ): compose.Outer
+  ): Future[compose.Outer]
 }
 
 object QueryRunner {
-  private class DefaultRunner[Resource](wr: WithResource[Resource])(
-      implicit ec: ExecutionContext
-  ) extends QueryRunner[Resource] {
-
+  private class DefaultRunner[Resource](wr: WithResource[Resource])
+      extends QueryRunner[Resource] {
     def apply[M[_], T](
         query: QueryT[M, Resource, T]
-    )(implicit compose: ComposeWithCompletion[M, T]): compose.Outer = {
-      wr { resource =>
-        compose(resource, query.run)(wr.releaseIfNecessary)
-      }
-    }
-
+    )(implicit compose: ComposeWithCompletion[M, T]): Future[compose.Outer] =
+      compose(wr, query.run)
   }
 
   // Default factory
   def apply[Resource](
       wr: WithResource[Resource]
-  )(implicit ec: ExecutionContext): QueryRunner[Resource] =
+  ): QueryRunner[Resource] =
     new DefaultRunner(wr)
 }

core/src/main/scala/core/database/WithResource.scala

@@ -1,7 +1,7 @@
 package com.zengularity.querymonad.core.database
 
-trait WithResource[Resource] {
-  def apply[A](f: Resource => A): A
+import scala.concurrent.Future
 
-  def releaseIfNecessary(resource: Resource): Unit
+trait WithResource[Resource] {
+  def apply[A](f: Resource => Future[A]): Future[A]
 }

core/src/main/scala/core/database/package.scala

@@ -35,6 +35,11 @@ package object database {
     def liftF[M[_], Resource, A](ma: M[A]) =
       ReaderT.liftF[M, Resource, A](ma)
 
+    def lift[M[_], Resource, A](
+        query: Query[Resource, A]
+    )(implicit F: Applicative[M]) =
+      QueryT[M, Resource, A](query.map(F.pure).run)
+
     def fromQuery[M[_], Resource, A](
         query: Query[Resource, M[A]]
     ): QueryT[M, Resource, A] =

core/src/main/scala/core/module/sql/package.scala renamed to core/src/main/scala/module/sql/package.scala

@@ -1,8 +1,8 @@
-package com.zengularity.querymonad.core.module
+package com.zengularity.querymonad.module
 
 import java.sql.Connection
 
-import scala.concurrent.ExecutionContext
+// import scala.concurrent.ExecutionContext
 import scala.language.higherKinds
 
 import cats.Applicative
@@ -43,6 +43,11 @@ package object sql {
 
     def liftF[M[_], A](ma: M[A]) = QueryT.liftF[M, Connection, A](ma)
 
+    def lift[M[_], A](
+        query: SqlQuery[A]
+    )(implicit F: Applicative[M]) =
+      SqlQueryT[M, A](query.map(F.pure).run)
+
     def fromQuery[M[_], A](query: SqlQuery[M[A]]) =
       QueryT.fromQuery[M, Connection, A](query)
   }
@@ -57,9 +62,7 @@ package object sql {
   type SqlQueryRunner = QueryRunner[Connection]
 
   object SqlQueryRunner {
-    def apply(
-        wc: WithSqlConnection
-    )(implicit ec: ExecutionContext): SqlQueryRunner =
+    def apply(wc: WithSqlConnection): SqlQueryRunner =
       QueryRunner[Connection](wc)
   }
 

core/src/test/scala/module/sql/SqlQueryRunnerSpec.scala

@@ -1,4 +1,4 @@
-package com.zengularity.querymonad.test.core.module.sql
+package com.zengularity.querymonad.test.module.sql
 
 import acolyte.jdbc.{
   AcolyteDSL,
@@ -9,17 +9,14 @@ import acolyte.jdbc.{
 import org.specs2.concurrent.ExecutionEnv
 import org.specs2.mutable.Specification
 
-import com.zengularity.querymonad.core.module.sql.{
+import com.zengularity.querymonad.module.sql.{
   SqlQuery,
   SqlQueryRunner,
   SqlQueryT,
   WithSqlConnection
 }
-import com.zengularity.querymonad.test.core.module.sql.models.{
-  Material,
-  Professor
-}
-import com.zengularity.querymonad.test.core.module.sql.utils.SqlConnectionFactory
+import com.zengularity.querymonad.test.module.sql.models.{Material, Professor}
+import com.zengularity.querymonad.test.module.sql.utils.SqlConnectionFactory
 
 class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
 
@@ -128,9 +125,11 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
     // execute async queries
     "retrieve int value fetch in an async context" in {
       import scala.concurrent.Future
+      import scala.concurrent.duration._
       import anorm.{SQL, SqlParser}
       import acolyte.jdbc.RowLists
       import acolyte.jdbc.Implicits._
+
       val queryResult: AcolyteQueryResult =
         (RowLists.rowList1(classOf[Int] -> "res").append(5))
       val withSqlConnection: WithSqlConnection =
@@ -139,13 +138,16 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
       val query =
         SqlQueryT { implicit connection =>
           Future {
-            Thread.sleep(900) // to simulate a slow-down
+            Thread.sleep(1000) // to simulate a slow-down
             SQL("SELECT 5 as res")
               .as(SqlParser.int("res").single)
           }
         }
 
-      runner(query) aka "result" must beTypedEqualTo(5).await
+      runner(query) aka "result" must beTypedEqualTo(5).await(
+        retries = 1,
+        timeout = 2.seconds
+      )
     }
   }
 

core/src/test/scala/module/sql/models/Material.scala

@@ -1,11 +1,11 @@
-package com.zengularity.querymonad.test.core.module.sql.models
+package com.zengularity.querymonad.test.module.sql.models
 
 import anorm._
 import acolyte.jdbc.Implicits._
 import acolyte.jdbc.{QueryResult => AcolyteQueryResult}
 import acolyte.jdbc.RowLists.rowList4
 
-import com.zengularity.querymonad.core.module.sql.SqlQuery
+import com.zengularity.querymonad.module.sql.SqlQuery
 
 case class Material(id: Int, name: String, numberOfHours: Int, level: String)
 

core/src/test/scala/module/sql/models/Professor.scala

@@ -1,11 +1,11 @@
-package com.zengularity.querymonad.test.core.module.sql.models
+package com.zengularity.querymonad.test.module.sql.models
 
 import anorm._
 import acolyte.jdbc.Implicits._
 import acolyte.jdbc.{QueryResult => AcolyteQueryResult}
 import acolyte.jdbc.RowLists.rowList4
 
-import com.zengularity.querymonad.core.module.sql.SqlQuery
+import com.zengularity.querymonad.module.sql.SqlQuery
 
 case class Professor(id: Int, name: String, age: Int, material: Int)
 

core/src/test/scala/module/sql/utils/SqlConnectionFactory.scala

@@ -1,35 +1,37 @@
-package com.zengularity.querymonad.test.core.module.sql.utils
+package com.zengularity.querymonad.test.module.sql.utils
 
 import java.sql.Connection
 
+import scala.concurrent.Future
+import scala.concurrent.ExecutionContext.Implicits.global
+
 import acolyte.jdbc.{
   AcolyteDSL,
   QueryResult => AcolyteQueryResult,
   ScalaCompositeHandler
 }
 
-import com.zengularity.querymonad.core.module.sql.WithSqlConnection
+import com.zengularity.querymonad.module.sql.WithSqlConnection
 
 object SqlConnectionFactory {
 
   def withSqlConnection[A <: AcolyteQueryResult](
       resultsSet: A
   ): WithSqlConnection =
     new WithSqlConnection {
-      def apply[B](f: Connection => B): B =
-        AcolyteDSL.withQueryResult(resultsSet)(f)
+      def apply[B](f: Connection => Future[B]): Future[B] =
+        AcolyteDSL.withQueryResult(resultsSet) { connection =>
+          f(connection).andThen { case _ => connection.close() }
+        }
 
-      def releaseIfNecessary(connection: Connection): Unit = connection.close()
     }
 
   def withSqlConnection(handler: ScalaCompositeHandler): WithSqlConnection =
     new WithSqlConnection {
-      def apply[B](f: Connection => B): B = {
+      def apply[B](f: Connection => Future[B]): Future[B] = {
         val con = AcolyteDSL.connection(handler)
-        f(con)
+        f(con).andThen { case _ => con.close() }
       }
-
-      def releaseIfNecessary(connection: Connection): Unit = connection.close()
     }
 
 }