You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82 lines
2.3 KiB
82 lines
2.3 KiB
package wow.doge.http4sdemo.dto
|
|
|
|
import java.time.Instant
|
|
|
|
import io.circe.Printer
|
|
import io.circe.generic.semiauto._
|
|
import io.scalaland.chimney.dsl._
|
|
import org.http4s.EntityEncoder
|
|
import org.http4s.circe.streamJsonArrayEncoderWithPrinterOf
|
|
import slick.jdbc.JdbcProfile
|
|
import wow.doge.http4sdemo.slickcodegen.Tables
|
|
|
|
final case class Book(
|
|
id: Int,
|
|
title: String,
|
|
authorId: Int,
|
|
createdAt: Instant
|
|
)
|
|
object Book {
|
|
def tupled = (Book.apply _).tupled
|
|
implicit val ec = deriveCodec[Book]
|
|
// implicit def streamEntityEncoder[F[_]]
|
|
// : EntityEncoder[F, fs2.Stream[F, Book]] =
|
|
// streamJsonArrayEncoderWithPrinterOf(Printer.noSpaces)
|
|
def fromBooksRow(row: Tables.BooksRow) = row.transformInto[Book]
|
|
def fromBooksTableFn(implicit profile: JdbcProfile) = {
|
|
import profile.api._
|
|
(b: Tables.Books) => (b.id, b.title, b.authorId, b.createdAt).mapTo[Book]
|
|
}
|
|
def fromBooksTable(implicit profile: JdbcProfile) =
|
|
Tables.Books.map(fromBooksTableFn)
|
|
|
|
}
|
|
|
|
final case class NewBook(title: String, authorId: Int)
|
|
object NewBook {
|
|
def tupled = (NewBook.apply _).tupled
|
|
implicit val decoder = deriveDecoder[NewBook]
|
|
def fromBooksTable(implicit profile: JdbcProfile) = {
|
|
import profile.api._
|
|
|
|
Tables.Books.map(b => (b.title, b.authorId).mapTo[NewBook])
|
|
}
|
|
}
|
|
|
|
final case class BookUpdate(title: Option[String], authorId: Option[Int]) {
|
|
import com.softwaremill.quicklens._
|
|
def update(row: Tables.BooksRow): Tables.BooksRow =
|
|
row
|
|
.modify(_.title)
|
|
.setToIfDefined(title)
|
|
.modify(_.authorId)
|
|
.setToIfDefined(authorId)
|
|
}
|
|
object BookUpdate {
|
|
implicit val decoder = deriveDecoder[BookUpdate]
|
|
}
|
|
|
|
final case class Author(id: Int, name: String)
|
|
object Author {
|
|
def tupled = (Author.apply _).tupled
|
|
implicit val codec = deriveCodec[Author]
|
|
implicit def streamEntityEncoder[F[_]]
|
|
: EntityEncoder[F, fs2.Stream[F, Author]] =
|
|
streamJsonArrayEncoderWithPrinterOf(Printer.noSpaces)
|
|
}
|
|
|
|
final case class NewAuthor(name: String)
|
|
|
|
final case class BookWithAuthor(
|
|
id: Int,
|
|
title: String,
|
|
author: Author,
|
|
createdAt: Instant
|
|
)
|
|
object BookWithAuthor {
|
|
def tupled = (BookWithAuthor.apply _).tupled
|
|
implicit val codec = deriveCodec[BookWithAuthor]
|
|
implicit def streamEntityEncoder[F[_]]
|
|
: EntityEncoder[F, fs2.Stream[F, BookWithAuthor]] =
|
|
streamJsonArrayEncoderWithPrinterOf(Printer.noSpaces)
|
|
}
|