feat(sql): add zio-blocks-sql module — Schema-driven SQL database access

build.sbt

@@ -131,6 +131,9 @@ lazy val root = project
     scope.jvm,
     scope.js,
     `scope-examples`,
+    sql.jvm,
+    sql.js,
+    `sql-zio`,
     schema.jvm,
     schema.js,
     `schema-avro`,
@@ -299,6 +302,45 @@ lazy val scope = crossProject(JSPlatform, JVMPlatform)
     coverageMinimumBranchTotal := 65
   )
 
+lazy val sql = crossProject(JSPlatform, JVMPlatform)
+  .crossType(CrossType.Full)
+  .dependsOn(schema, scope)
+  .settings(stdSettings("zio-blocks-sql", Seq(BuildHelper.Scala3, BuildHelper.Scala33)))
+  .settings(crossProjectSettings)
+  .settings(buildInfoSettings("zio.blocks.sql"))
+  .enablePlugins(BuildInfoPlugin)
+  .jvmSettings(mimaSettings(failOnProblem = false))
+  .jsSettings(jsSettings)
+  .settings(
+    libraryDependencies ++= Seq(
+      "dev.zio" %%% "zio-test"     % "2.1.24" % Test,
+      "dev.zio" %%% "zio-test-sbt" % "2.1.24" % Test
+    ),
+    coverageMinimumStmtTotal   := 0,
+    coverageMinimumBranchTotal := 0
+  )
+  .jvmSettings(
+    libraryDependencies ++= Seq(
+      "org.xerial"     % "sqlite-jdbc" % "3.49.1.0" % Test,
+      "org.postgresql" % "postgresql"  % "42.7.5"   % Test
+    )
+  )
+
+lazy val `sql-zio` = project
+  .settings(stdSettings("zio-blocks-sql-zio", Seq(BuildHelper.Scala3, BuildHelper.Scala33)))
+  .dependsOn(sql.jvm)
+  .settings(buildInfoSettings("zio.blocks.sql.zio"))
+  .enablePlugins(BuildInfoPlugin)
+  .settings(
+    libraryDependencies ++= Seq(
+      "dev.zio" %% "zio"          % "2.1.24",
+      "dev.zio" %% "zio-test"     % "2.1.24" % Test,
+      "dev.zio" %% "zio-test-sbt" % "2.1.24" % Test
+    ),
+    coverageMinimumStmtTotal   := 0,
+    coverageMinimumBranchTotal := 0
+  )
+
 lazy val `scope-examples` = project
   .settings(stdSettings("zio-blocks-scope-examples", Seq(BuildHelper.Scala3)))
   .dependsOn(scope.jvm)

sql-zio/src/main/scala/zio/blocks/sql/zio/TransactorZIO.scala

@@ -0,0 +1,36 @@
+package zio.blocks.sql.zio
+
+import zio._
+import zio.blocks.sql._
+
+class TransactorZIO(underlying: Transactor) {
+
+  def connect[A](f: DbCon ?=> A): Task[A] =
+    ZIO.attemptBlocking(underlying.connect(f))
+
+  def transact[A](f: DbTx ?=> A): Task[A] =
+    ZIO.attemptBlocking(underlying.transact(f))
+}
+
+object TransactorZIO {
+  def fromTransactor(transactor: Transactor): TransactorZIO =
+    new TransactorZIO(transactor)
+
+  def fromUrl(url: String, dialect: SqlDialect): TransactorZIO =
+    new TransactorZIO(JdbcTransactor.fromUrl(url, dialect))
+
+  def fromUrl(
+    url: String,
+    user: String,
+    password: String,
+    dialect: SqlDialect
+  ): TransactorZIO =
+    new TransactorZIO(JdbcTransactor.fromUrl(url, user, password, dialect))
+
+  def fromDataSource(dataSource: javax.sql.DataSource, dialect: SqlDialect): TransactorZIO =
+    new TransactorZIO(JdbcTransactor.fromDataSource(dataSource, dialect))
+
+  // ZLayer for dependency injection
+  def layer(url: String, dialect: SqlDialect): ZLayer[Any, Nothing, TransactorZIO] =
+    ZLayer.succeed(fromUrl(url, dialect))
+}

sql/jvm/src/main/scala/zio/blocks/sql/JdbcConnection.scala

@@ -0,0 +1,46 @@
+package zio.blocks.sql
+
+import java.sql.Connection
+
+class JdbcConnection(val underlying: Connection) extends DbConnection {
+
+  def prepareStatement(sql: String): DbPreparedStatement =
+    new JdbcPreparedStatement(underlying.prepareStatement(sql))
+
+  def close(): Unit = underlying.close()
+
+  def isClosed: Boolean = underlying.isClosed
+
+  def setAutoCommit(autoCommit: Boolean): Unit = underlying.setAutoCommit(autoCommit)
+
+  def getAutoCommit: Boolean = underlying.getAutoCommit
+
+  def commit(): Unit = underlying.commit()
+
+  def rollback(): Unit = underlying.rollback()
+}
+
+class JdbcPreparedStatement(val underlying: java.sql.PreparedStatement) extends DbPreparedStatement {
+
+  def executeQuery(): DbResultSet =
+    new JdbcResultSet(underlying.executeQuery())
+
+  def executeUpdate(): Int = underlying.executeUpdate()
+
+  def close(): Unit = underlying.close()
+
+  def paramWriter: DbParamWriter = new JdbcParamWriter(underlying)
+
+  def addBatch(): Unit = underlying.addBatch()
+
+  def executeBatch(): Array[Int] = underlying.executeBatch()
+}
+
+class JdbcResultSet(val underlying: java.sql.ResultSet) extends DbResultSet {
+
+  def next(): Boolean = underlying.next()
+
+  def close(): Unit = underlying.close()
+
+  def reader: DbResultReader = new JdbcResultReader(underlying)
+}

sql/jvm/src/main/scala/zio/blocks/sql/JdbcParamWriter.scala

@@ -0,0 +1,41 @@
+package zio.blocks.sql
+
+import java.sql.PreparedStatement
+
+class JdbcParamWriter(val underlying: PreparedStatement) extends DbParamWriter {
+
+  def setInt(index: Int, value: Int): Unit = underlying.setInt(index, value)
+
+  def setLong(index: Int, value: Long): Unit = underlying.setLong(index, value)
+
+  def setDouble(index: Int, value: Double): Unit = underlying.setDouble(index, value)
+
+  def setFloat(index: Int, value: Float): Unit = underlying.setFloat(index, value)
+
+  def setBoolean(index: Int, value: Boolean): Unit = underlying.setBoolean(index, value)
+
+  def setString(index: Int, value: String): Unit = underlying.setString(index, value)
+
+  def setBigDecimal(index: Int, value: java.math.BigDecimal): Unit = underlying.setBigDecimal(index, value)
+
+  def setBytes(index: Int, value: Array[Byte]): Unit = underlying.setBytes(index, value)
+
+  def setShort(index: Int, value: Short): Unit = underlying.setShort(index, value)
+
+  def setByte(index: Int, value: Byte): Unit = underlying.setByte(index, value)
+
+  def setLocalDate(index: Int, value: java.time.LocalDate): Unit = underlying.setObject(index, value)
+
+  def setLocalDateTime(index: Int, value: java.time.LocalDateTime): Unit = underlying.setObject(index, value)
+
+  def setLocalTime(index: Int, value: java.time.LocalTime): Unit = underlying.setObject(index, value)
+
+  def setInstant(index: Int, value: java.time.Instant): Unit =
+    underlying.setTimestamp(index, java.sql.Timestamp.from(value))
+
+  def setDuration(index: Int, value: java.time.Duration): Unit = underlying.setString(index, value.toString)
+
+  def setUUID(index: Int, value: java.util.UUID): Unit = underlying.setObject(index, value)
+
+  def setNull(index: Int, sqlType: Int): Unit = underlying.setNull(index, sqlType)
+}

sql/jvm/src/main/scala/zio/blocks/sql/JdbcResultReader.scala

@@ -0,0 +1,51 @@
+package zio.blocks.sql
+
+import java.sql.ResultSet
+import java.util.UUID
+
+class JdbcResultReader(val underlying: ResultSet) extends DbResultReader {
+
+  def getInt(index: Int): Int = underlying.getInt(index)
+
+  def getLong(index: Int): Long = underlying.getLong(index)
+
+  def getDouble(index: Int): Double = underlying.getDouble(index)
+
+  def getFloat(index: Int): Float = underlying.getFloat(index)
+
+  def getBoolean(index: Int): Boolean = underlying.getBoolean(index)
+
+  def getString(index: Int): String = underlying.getString(index)
+
+  def getBigDecimal(index: Int): java.math.BigDecimal = underlying.getBigDecimal(index)
+
+  def getBytes(index: Int): Array[Byte] = underlying.getBytes(index)
+
+  def getShort(index: Int): Short = underlying.getShort(index)
+
+  def getByte(index: Int): Byte = underlying.getByte(index)
+
+  def getLocalDate(index: Int): java.time.LocalDate = underlying.getObject(index, classOf[java.time.LocalDate])
+
+  def getLocalDateTime(index: Int): java.time.LocalDateTime =
+    underlying.getObject(index, classOf[java.time.LocalDateTime])
+
+  def getLocalTime(index: Int): java.time.LocalTime = underlying.getObject(index, classOf[java.time.LocalTime])
+
+  def getInstant(index: Int): java.time.Instant = {
+    val ts = underlying.getTimestamp(index)
+    if (ts == null) null else ts.toInstant
+  }
+
+  def getDuration(index: Int): java.time.Duration = {
+    val s = underlying.getString(index)
+    if (s == null) null else java.time.Duration.parse(s)
+  }
+
+  def getUUID(index: Int): UUID = {
+    val s = underlying.getString(index)
+    if (s == null) null else UUID.fromString(s)
+  }
+
+  def wasNull: Boolean = underlying.wasNull()
+}

sql/jvm/src/main/scala/zio/blocks/sql/JdbcTransactor.scala

@@ -0,0 +1,62 @@
+package zio.blocks.sql
+
+import java.sql.{Connection, DriverManager}
+
+class JdbcTransactor(
+  connectionFactory: () => Connection,
+  val dialect: SqlDialect,
+  val sqlLogger: SqlLogger = SqlLogger.noop
+) extends Transactor {
+
+  def connect[A](f: DbCon ?=> A): A = {
+    val conn   = connectionFactory()
+    val dbConn = new JdbcConnection(conn)
+    try {
+      given con: DbCon = new DbCon {
+        val connection: DbConnection = dbConn
+        val dialect: SqlDialect      = JdbcTransactor.this.dialect
+        val logger: SqlLogger        = JdbcTransactor.this.sqlLogger
+      }
+      f
+    } finally {
+      try dbConn.close()
+      catch { case _: Throwable => () }
+    }
+  }
+
+  def transact[A](f: DbTx ?=> A): A = {
+    val conn   = connectionFactory()
+    val dbConn = new JdbcConnection(conn)
+    conn.setAutoCommit(false)
+    try {
+      given tx: DbTx = new DbTx {
+        val connection: DbConnection = dbConn
+        val dialect: SqlDialect      = JdbcTransactor.this.dialect
+        val logger: SqlLogger        = JdbcTransactor.this.sqlLogger
+      }
+      val result = f
+      conn.commit()
+      result
+    } catch {
+      case e: Throwable =>
+        try conn.rollback()
+        catch { case rb: Throwable => e.addSuppressed(rb) }
+        throw e
+    } finally {
+      try dbConn.close()
+      catch { case _: Throwable => () }
+    }
+  }
+}
+
+object JdbcTransactor {
+
+  def fromUrl(url: String, dialect: SqlDialect): JdbcTransactor =
+    new JdbcTransactor(() => DriverManager.getConnection(url), dialect)
+
+  def fromUrl(url: String, user: String, password: String, dialect: SqlDialect): JdbcTransactor =
+    new JdbcTransactor(() => DriverManager.getConnection(url, user, password), dialect)
+
+  def fromDataSource(dataSource: javax.sql.DataSource, dialect: SqlDialect): JdbcTransactor =
+    new JdbcTransactor(() => dataSource.getConnection, dialect)
+}