Upgrade libraries

build.sbt

@@ -10,7 +10,7 @@ lazy val config = ConfigFactory.parseFile(prjDir / "application.conf")
 
 val commonSettings = Seq(
   organization := "io.github.doolse",
-  version := "0.1.1-SNAPSHOT",
+  version := "0.1.2-SNAPSHOT",
   scalaVersion := "2.12.3",
   resolvers += Resolver.sonatypeRepo("snapshots"),
 
@@ -45,8 +45,9 @@ val subSettings = Seq(
   name := "simpledba-" + baseDirectory.value.getName,
   testOptions in Test += Tests.Argument(TestFrameworks.ScalaCheck, "-s", "10"),
   scalacOptions += "-Ypartial-unification",
-  scalacOptions ++= Option("-Xlog-implicits").filter(_ => config.getBoolean("debug.implicits")).toSeq,
-  addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.3")
+  scalacOptions ++= Option("-P:splain:implicits:true").filter(_ => config.getBoolean("debug.implicits")).toSeq,
+  addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.3"),
+  addCompilerPlugin("io.tryp" %% "splain" % "0.2.6")
 ) ++ commonSettings
 
 lazy val coreDep = core % "test->test;compile->compile"

cassandra/src/main/scala/io/doolse/simpledba/cassandra/CassandraMapper.scala

@@ -177,7 +177,7 @@ object MapQuery extends Poly2 {
       val selectAll = CassandraSelect(table, allNames, Seq.empty, Seq.empty, false)
       val select = CassandraSelect(table, allNames, exactMatch(pkCols), Seq.empty, false)
 
-      val rsStream = (s: Stream[Effect, ResultSet]) => s.flatMap(rs => CassandraIO.rowsStream(rs).translateSync(task2Effect))
+      val rsStream = (s: Stream[Effect, ResultSet]) => s.flatMap(rs => CassandraIO.rowsStream(rs).translate(task2Effect))
       .map(materialize)
 
       new UniqueQuery[Effect, T, PKV] {
@@ -238,7 +238,7 @@ object MapQuery extends Poly2 {
             val select = baseSelect.copy(where = baseSelect.where ++ lw ++ uw, ordering = ordering)
             s.prepareAndBind(select, valsToBinding(pkPhysV(c) ++ lv ++ uv))
           }
-        }.flatMap(rs => CassandraIO.rowsStream(rs).translateSync(task2Effect))
+        }.flatMap(rs => CassandraIO.rowsStream(rs).translate(task2Effect))
           .map(r => materialize(rowMaterializer(r)))
       }
       RangeQuery(None, doQuery)

cassandra/src/main/scala/io/doolse/simpledba/cassandra/package.scala

@@ -16,7 +16,7 @@ package object cassandra {
 
   implicit val cassandraFlusher : Flushable[Effect] = new Flushable[Effect] {
     def flush[A](f: Stream[Effect, WriteOp]): Effect[Unit] = StateT.inspectF {
-      s => f.through(CassandraIO.writePipe).run.runA(s)
+      s => f.through(CassandraIO.writePipe).compile.drain.runA(s)
     }
   }
 }

cassandra/src/test/scala/test/QuickstartExample.scala

@@ -47,8 +47,8 @@ object QuickstartExample extends App {
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Honda", "Civic", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Ford", "Laser", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Hyundai", "Accent", magId))
-      cars <- queries.carsForUser(magId, lower = Exclusive("Honda")).runLog
-      users <- queries.usersByFirstName("Jolse").runLog
+      cars <- queries.carsForUser(magId, lower = Exclusive("Honda")).compile.toVector
+      users <- queries.usersByFirstName("Jolse").compile.toVector
     } yield (cars ++ users).mkString("\n")).run(sessionConfig).unsafeRunSync()
   }
 }

circe/build.sbt

@@ -1,4 +1,4 @@
-val circeVersion = "0.8.0"
+val circeVersion = "0.9.1"
 
 libraryDependencies ++= Seq(
   "io.circe" %% "circe-core",

core/build.sbt

@@ -1,6 +1,6 @@
 libraryDependencies ++= Seq(
   "com.chuusai" %% "shapeless" % "2.3.2",
-  "co.fs2" %% "fs2-core" % "0.10.0-M6",
+  "co.fs2" %% "fs2-core" % "0.10.1",
   "com.typesafe" % "config" % "1.3.0")
 
 libraryDependencies ++= Seq("org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.4" % Test,

core/src/test/scala/io/doolse/simpledba/test/CrudProperties.scala

@@ -20,7 +20,7 @@ object CrudProperties {
     implicit def runProp(fa: F[Prop]): Prop = run(fa)
 
     new Properties("CRUD ops") {
-      val countAll = (a: A) => findAll(a).runLog.map(_.count(a.==))
+      val countAll = (a: A) => findAll(a).compile.toVector.map(_.count(a.==))
 
 
       property("createReadDelete") = forAll { (a: A) =>

core/src/test/scala/io/doolse/simpledba/test/RangeQueryProperties.scala

@@ -87,8 +87,8 @@ abstract class RangeQueryProperties[F[_] : Monad : Sync : Flushable](implicit ra
         case _ => FilterRange(r1, r2)
       }
       run(for {
-        ascend <- q.queryWithOrder(same, range.lower, range.upper, asc = true).map(lens).runLog
-        descend <- q.queryWithOrder(same, range.lower, range.upper, asc = false).map(lens).runLog
+        ascend <- q.queryWithOrder(same, range.lower, range.upper, asc = true).map(lens).compile.toVector
+        descend <- q.queryWithOrder(same, range.lower, range.upper, asc = false).map(lens).compile.toVector
       } yield {
         val filtered = vSame.map(lens).filter(r => range.contains(r)(ord))
         val ascExpected = filtered.sorted(ord)

core/src/test/scala/io/doolse/simpledba/test/SortedQueryProperties.scala

@@ -69,8 +69,8 @@ abstract class SortedQueryProperties[F[_] : Monad : Sync : Flushable](implicit a
       _ <- queries.writes.truncate >> queries.writes.bulkInsert(Stream(vSame: _*))
       p = sortQ.map {
         case (name, oq @ OrderQuery(lens, q)) => run(for {
-          ascend <- q.queryWithOrder(same, asc = true).map(lens).runLog
-          descend <- q.queryWithOrder(same, asc = false).map(lens).runLog
+          ascend <- q.queryWithOrder(same, asc = true).map(lens).compile.toVector
+          descend <- q.queryWithOrder(same, asc = false).map(lens).compile.toVector
         } yield {
           val ord = oq.o
           val ascExpected = vSame.map(lens).sorted(ord)

core/src/test/scala/io/doolse/simpledba/test/TestCreator.scala

@@ -55,15 +55,15 @@ object TestCreator {
       _ <- writeUsers.insert(User("Emma", "Maginnis", 1982))
       _ <- writeUsers.insert(User("Jolse", "Mahinnis", 1985))
       _ <- writeInst.insert(orig)
-      res2 <- instByPK(1L).runLast
-      res <- instByPK(517573426L).runLast
+      res2 <- instByPK(1L).compile.last
+      res <- instByPK(517573426L).compile.last
       _ <- writeInst.update(orig, updated)
-      res3 <- instByPK(2L).runLast
+      res3 <- instByPK(2L).compile.last
       _ <- writeInst.update(updated, updatedAgain)
-      res4 <- instByPK(2L).runLast
-      all <- queryByLastName.queryWithOrder("Maginnis", true).runLog
-      allFirst <- querybyFirstName.queryWithOrder("Jolse", false).runLog
-      fullPK <- queryByFullName(Username("Jolse", "Maginnis")).runLast
+      res4 <- instByPK(2L).compile.last
+      all <- queryByLastName.queryWithOrder("Maginnis", true).compile.toVector
+      allFirst <- querybyFirstName.queryWithOrder("Jolse", false).compile.toVector
+      fullPK <- queryByFullName(Username("Jolse", "Maginnis")).compile.toVector
       _ <- res4.map(writeInst.delete).sequence
     } yield {
       s"""

dynamodb/src/main/scala/io/doolse/simpledba/dynamodb/DynamoDBIO.scala

@@ -65,7 +65,7 @@ object DynamoDBIO {
       val batchWriteMapJava = new java.util.HashMap[String, java.util.List[WriteRequest]]
       val m = batchWriteMapJava.asScala
       val b = mutable.Buffer[UpdateItemRequest]()
-      c.foreach {
+      c.force.foreach {
         case DynamoDBBatchable(n, wr) => m.getOrElseUpdate(n, new util.ArrayList[WriteRequest]).add(wr)
         case DynamoDBUpdate(uir) => b += uir
       }

dynamodb/src/main/scala/io/doolse/simpledba/dynamodb/DynamoDBMapper.scala

@@ -311,7 +311,7 @@ object mapQuery extends Poly2 {
               val fullKeySeq = Seq(dt.realPK(pkIndexes.map(pkOrigSeq))) ++ dt.fullSK(false, skIndexes.map(pkOrigSeq))
               keyAndAttrs.withKeys(asAttrMap(fullKeySeq))
               (v, a)
-          }.toArray.toMap
+          }.force.toArray.toMap
           batchGetResultStream(new BatchGetItemRequest(Map(tableName -> keyAndAttrs).asJava)).map(_._2).map(createMaterializer).map(dt.materializer).map { t =>
             val a = pkvs(helper.extractKey(t).head)
             (a, Some(t))

dynamodb/src/main/scala/io/doolse/simpledba/dynamodb/DynamoDBUtils.scala

@@ -40,14 +40,14 @@ object DynamoDBUtils {
   } yield ()
 
   def waitForStatus(s: DynamoDBSession, tableNames: Vector[String], status: Option[String]): Stream[IO, Unit] = for {
-    statii <- Stream.eval(statuses(s, tableNames).runLog)
+    statii <- Stream.eval(statuses(s, tableNames).compile.toVector)
     notReady = statii.filter(_._2 != status)
     _ <- if (notReady.isEmpty) Stream.empty.covary[IO] else
         Stream.bracket(IO(Thread.sleep(FiniteDuration(2, TimeUnit.SECONDS).toMillis)))(_ => waitForStatus(s, notReady.map(_._1).toVector, status), IO.pure)
   } yield ()
 
   def statuses(s: DynamoDBSession, tableNames: Vector[String]) = for {
-    tn <- Stream(tableNames: _*)
+    tn <- Stream(tableNames: _*).covary[IO]
     dtrA <- Stream.eval(s.request(describeTableAsync, new DescribeTableRequest(tn)).attempt)
   } yield {
     val ts = dtrA match {

dynamodb/src/main/scala/io/doolse/simpledba/dynamodb/package.scala

@@ -16,7 +16,7 @@ package object dynamodb {
 
   implicit val dynamoFlusher : Flushable[Effect] = new Flushable[Effect] {
     def flush[A](f: Stream[Effect, WriteOp]): Effect[Unit] = StateT.inspectF {
-      s => f.through(DynamoDBIO.writePipe).run.runA(s)
+      s => f.through(DynamoDBIO.writePipe).compile.drain.runA(s)
     }
   }
 }

dynamodb/src/test/scala/test/QuickstartExampleDynamo.scala

@@ -55,8 +55,8 @@ object QuickstartExampleDynamo extends App {
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Honda", "Civic", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Ford", "Laser", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Hyundai", "Accent", magId))
-      cars <- queries.carsForUser(magId, lower = "Ford", higher = Exclusive("Hyundai")).runLog
-      users <- queries.usersByFirstName("Jolse").runLog
+      cars <- queries.carsForUser(magId, lower = "Ford", higher = Exclusive("Hyundai")).compile.toVector
+      users <- queries.usersByFirstName("Jolse").compile.toVector
     } yield (cars ++ users).mkString("\n")).run(session).unsafeRunSync()
   }
 }

jdbc/src/main/scala/io/doolse/simpledba/jdbc/JDBCIO.scala

@@ -36,7 +36,7 @@ object JDBCIO {
   }
 
   def pureJDBC[A](a: A) : Effect[A] = StateT.pure(a)
-  def liftJDBC[A](a: IO[A]): Effect[A] = StateT.lift(a)
+  def liftJDBC[A](a: IO[A]): Effect[A] = StateT.liftF(a)
 
   def rowsStream[A](open: Effect[ResultSet]): Stream[Effect, ResultSet] = {
     def nextLoop(rs: ResultSet): Stream[Effect, ResultSet] = {
@@ -59,14 +59,14 @@ object JDBCIO {
     st.segmentN(1000).evalMap { chunk =>
       val batches = chunk.map {
         case JDBCWrite(q, v) => (q, v)
-      }.toVector.groupBy(_._1).toSeq
+      }.force.toVector.groupBy(_._1).toSeq
       StateT.inspectF { (s:JDBCSession) =>
         val alls: Stream[IO, Stream[IO, Unit]] = Stream.emits {
           batches.map {
             b => Stream.eval(s.execBatch(b._1, b._2.map(_._2)))
           }
         }
-        alls.join(4).run
+        alls.join(4).compile.drain
       }
     }
   }

jdbc/src/main/scala/io/doolse/simpledba/jdbc/JDBCUtils.scala

@@ -5,7 +5,7 @@ import java.sql.SQLType
 import cats.effect.IO
 import cats.syntax.traverse._
 import cats.instances.vector._
-import cats.syntax.cartesian._
+import cats.syntax.apply._
 
 
 /**

jdbc/src/main/scala/io/doolse/simpledba/jdbc/package.scala

@@ -15,7 +15,7 @@ package object jdbc {
 
   implicit val jdbcFlusher : Flushable[Effect] = new Flushable[Effect] {
     def flush[A](f: Stream[Effect, WriteOp]): Effect[Unit] = StateT.inspectF {
-      s => f.to(JDBCIO.writeSink).run.runA(s)
+      s => f.to(JDBCIO.writeSink).compile.drain.runA(s)
     }
   }
 }

jdbc/src/test/scala/test/QuickstartExample.scala

@@ -47,8 +47,8 @@ object QuickstartExample extends App {
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Honda", "Civic", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Ford", "Laser", magId))
       _ <- queries.cars.insert(Car(UUID.randomUUID(), "Hyundai", "Accent", magId))
-      cars <- queries.carsForUser(magId, lower = Inclusive("Honda")).runLog
-      users <- queries.usersByFirstName("Jolse").runLog
+      cars <- queries.carsForUser(magId, lower = Inclusive("Honda")).compile.toVector
+      users <- queries.usersByFirstName("Jolse").compile.toVector
     } yield (cars ++ users).mkString("\n")).runA(sessionConfig).unsafeRunSync()
   }
 }