Query interpreter (#12)

* Refactor QueryRunner with WithConnection trait

* Abstract Connection in Query + add module for SQL

Author: stankoua

core/src/main/scala/core/database/Database.scala

@@ -1,29 +1,24 @@
 package com.zengularity.querymonad.core.database
 
-import javax.sql.DataSource
-
 import scala.concurrent.{ExecutionContext, Future}
 
-class QueryRunner(
-    db: Database,
-    ec: ExecutionContext
-) {
-  def run[A](query: Query[A]): Future[A] =
-    Future {
-      db.withConnection(query.run)
-    }(ec)
-
-  // TODO: Remove with a transaction run at context level
-  def commit[A](query: Query[A]): Future[A] =
-    Future {
-      db.withTransaction(query.run)
-    }(ec)
+/**
+  * A class who can run a Query.
+  */
+sealed trait QueryRunner[Resource] {
+  def apply[T](query: Query[Resource, T]): Future[T]
 }
 
 object QueryRunner {
-  def apply(db: Database, ec: ExecutionContext) =
-    new QueryRunner(db, ec)
+  private class DefaultRunner[Resource](wr: WithResource[Resource])(
+      implicit ec: ExecutionContext)
+      extends QueryRunner[Resource] {
+    def apply[T](query: Query[Resource, T]): Future[T] =
+      Future(wr(query.run))
+  }
 
-  def apply(ds: DataSource, ec: ExecutionContext) =
-    new QueryRunner(Database(ds), ec)
+  // Default factory
+  def apply[Resource](wr: WithResource[Resource])(
+      implicit ec: ExecutionContext): QueryRunner[Resource] =
+    new DefaultRunner(wr)
 }

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

@@ -0,0 +1,5 @@
+package com.zengularity.querymonad.core.database
+
+trait WithResource[Resource] {
+  def apply[A](f: Resource => A): A
+}

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

@@ -1,34 +1,34 @@
 package com.zengularity.querymonad.core
 
-import java.sql.Connection
-
 import scala.language.higherKinds
 
 import cats.{Applicative, Id}
 import cats.data.{Reader, ReaderT}
 
 package object database {
-  type Query[A] = Reader[Connection, A]
+  type Query[Resource, A] = Reader[Resource, A]
 
   object Query {
-    def pure[A](a: A) = ReaderT.pure[Id, Connection, A](a)
+    def pure[Resource, A](a: A) = ReaderT.pure[Id, Resource, A](a)
 
-    val ask = ReaderT.ask[Id, Connection]
+    def ask[Resource] = ReaderT.ask[Id, Resource]
 
-    def apply[A](f: Connection => A) = new Query(f)
+    def apply[Resource, A](f: Resource => A) = new Query(f)
   }
 
-  type QueryT[F[_], A] = ReaderT[F, Connection, A]
+  type QueryT[F[_], Resource, A] = ReaderT[F, Resource, A]
 
   object QueryT {
-    def pure[M[_]: Applicative, A](a: A) = ReaderT.pure[M, Connection, A](a)
+    def pure[M[_]: Applicative, Resource, A](a: A) =
+      ReaderT.pure[M, Resource, A](a)
 
-    def ask[M[_]: Applicative] = ReaderT.ask[M, Connection]
+    def ask[M[_]: Applicative, Resource] = ReaderT.ask[M, Resource]
 
-    def liftF[M[_], A](ma: M[A]) = ReaderT.liftF[M, Connection, A](ma)
+    def liftF[M[_], Resource, A](ma: M[A]) = ReaderT.liftF[M, Resource, A](ma)
   }
 
-  type QueryO[A] = QueryT[Option, A]
+  type QueryO[Resource, A] = QueryT[Option, Resource, A]
 
-  type QueryE[A, Err] = QueryT[({ type Res[T] = Either[Err, T] })#Res, A]
+  type QueryE[Resource, A, Err] =
+    QueryT[({ type F[T] = Either[Err, T] })#F, Resource, A]
 }

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

@@ -0,0 +1,33 @@
+package com.zengularity.querymonad.core.module
+
+import java.sql.Connection
+
+import scala.concurrent.ExecutionContext
+
+import com.zengularity.querymonad.core.database.{
+  Query,
+  QueryRunner,
+  WithResource
+}
+
+package object sql {
+  type SqlQuery[A] = Query[Connection, A]
+
+  object SqlQuery {
+    def pure[A](a: A) = Query.pure[Connection, A](a)
+
+    val ask = Query.ask[Connection]
+
+    def apply[A](f: Connection => A) = new SqlQuery(f)
+  }
+
+  type WithSqlConnection = WithResource[Connection]
+
+  type SqlQueryRunner = QueryRunner[Connection]
+
+  object SqlQueryRunner {
+    def apply(wc: WithSqlConnection)(
+        implicit ec: ExecutionContext): SqlQueryRunner =
+      QueryRunner[Connection](wc)
+  }
+}

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

@@ -0,0 +1,12 @@
+package com.zengularity.querymonad.examples.database
+
+import java.sql.Connection
+
+import play.api.db.Database
+
+import com.zengularity.querymonad.core.module.sql.WithSqlConnection
+
+class WithPlayTransaction(db: Database) extends WithSqlConnection {
+  def apply[A](f: Connection => A): A =
+    db.withTransaction(f)
+}

examples/sample-app/app/database/WithPlayTransaction.scala

@@ -1,7 +1,5 @@
 package com.zengularity.querymonad.examples.wiring
 
-import scala.concurrent.ExecutionContext
-
 import anorm._
 import play.api.ApplicationLoader.Context
 import play.api._
@@ -10,7 +8,8 @@ import play.api.mvc.Results._
 import play.api.routing.Router
 import play.api.routing.sird._
 
-import com.zengularity.querymonad.core.database.{Query, QueryRunner}
+import com.zengularity.querymonad.core.module.sql.{SqlQuery, SqlQueryRunner}
+import com.zengularity.querymonad.examples.database.WithPlayTransaction
 
 class AppComponents(context: Context)
     extends BuiltInComponentsFromContext(context)
@@ -20,26 +19,39 @@ class AppComponents(context: Context)
 
   val db = dbApi.database("default")
 
-  val queryRunner = QueryRunner(db.dataSource, implicitly[ExecutionContext])
+  val queryRunner = SqlQueryRunner(new WithPlayTransaction(db))
 
   val router: Router = Router.from {
 
     // Essentially copied verbatim from the SIRD example
     case GET(p"/hello/$to") =>
       Action.async {
-        val query = Query.pure(to)
-        queryRunner.run(query).map { to =>
+        val query = SqlQuery.pure(to)
+        queryRunner(query).map { to =>
           Ok(s"Hello $to")
         }
       }
 
     case GET(p"/sqrt/${double(num)}") =>
       Action.async {
-        val query = Query(implicit c =>
+        val query = SqlQuery(implicit c =>
           SQL"select sqrt($num) as result".as(SqlParser.int("result").single))
 
-        queryRunner.run(query).map(r => Ok(r.toString))
+        queryRunner(query).map(r => Ok(r.toString))
       }
+
+    case GET(p"/ping/$cmd") =>
+      Action.async {
+        val query =
+          for {
+            number <- SqlQuery.pure(42)
+            text <- SqlQuery(implicit c =>
+              SQL"select $cmd as result".as(SqlParser.str("result").single))
+          } yield (text + number)
+
+        queryRunner(query).map(r => Ok(r.toString))
+      }
+
   }
 }