spring-kotlin-exposed

playground for spring-boot 2.*, kotlin, jetbrains-exposed, postgres, jsonb, flyway, docker

Yes, we can talk to a sql db. It's easy. No rocket science.
There is a life besides the "dark art of hibernate / jpa".
Alternatives: JDBI, Requery, rxjava-jdbc, Jooq, Querydsl ...

jetbrains exposed (overview)

wiki: https://github.com/JetBrains/Exposed/wiki
flavours:
- DSL Api: typesafe sql (immutable data structures)
- DAO Api: ORM-/ActiveRecord-style (mutable entities)
highlights:
- integrates with spring transaction manager
- works with flyway db migrations
- supports multiple datasources within one application (e.g.: source-db-1, source-db2, sink-db)
- speeds up startup of spring-boot
- low memory footprint (playground runs on 256M)
- precise and typesafe sql queries (WYSISWG)
- no runtime reflection magic
- writing add-ons is simple, e.g. custom db-column-types

Exposed DSL Api: examples

It's easy. No ORM magic. WYSIWYG.
Ready for starship java "enterprise" deployments.

    # The beauty of exposed-dsl... Simple. Readable. Typesafe.
    
    # Example: query db
 
    fun findAllBooksJoinAuthor() =
            (AuthorTable innerJoin BookTable)
                    .selectAll()
                    .map { 
                        BookRecordJoinAuthorRecord(
                            bookRecord = it.toBookRecord(), 
                            authorRecord = it.toAuthorRecord()
                        ) 
                    }
    
    # Example: db schema 
    
    object AuthorTable : Table("author") {
        val id = uuid("id").primaryKey()
        val createdAt = instant("created_at")
        val modifiedAt = instant("updated_at")
        val version = integer("version")
        val name = text("name")
    }
                    
    object BookTable : Table("book") {
        val id = uuid("id").primaryKey()
        val createdAt = instant("created_at")
        val modifiedAt = instant("updated_at")
        val version = integer("version")
        val authorId = (uuid("author_id") references AuthorTable.id)
        val title = varchar("title", 255)
        val status = enumerationByName("status", 255, BookStatus::class.java)
        val price = decimal("price", 15, 2)
    } 
    
    # Example: Table Record Structures as immutable data classes
    
    data class AuthorRecord(
            val id: UUID,
            val createdAt: Instant,
            val modifiedAt: Instant,
            val version: Int,
            val name: String
    )   
    
    data class BookRecord(
            val id: UUID,
            val createdAt: Instant,
            val modifiedAt: Instant,
            val version: Int,
            val authorId: UUID,
            val title: String,
            val status: BookStatus,
            val price: BigDecimal
    )

playground

    # build db + app and start everything using docker-compose
     
    $ make -C rest-api playground.up
    
    browse to: http://localhost:8080/swagger-ui.html

build

    $ make -C rest-api app.build

run local db (docker)

    $ make -C rest-api db-local.up

examples:

api tweeter: simple crud (tables: tweet).

# Highlights: postgres enum types
 
sql ..
 
CREATE TYPE TweetStatusType AS ENUM ('DRAFT', 'PENDING', 'PUBLISHED');

CREATE TABLE Tweet (
  (...)
  status TweetStatusType NOT NULL DEFAULT 'DRAFT'
);
 
kotlin ...
 
object TweetsTable : Table("tweet") {
    (...)
    val status = enumerationByNameAndSqlType(
            name = "status", sqlType = "TweetStatusType", klass = TweetStatus::class.java
    )
}

api bookstore: crud-ish (joined tables: author, book)
api bookz: jsonb examples (tables: bookz)

This example project is based on ...

Whats wrong with orm, jpa, hibernate and in-memory h2-db these days ?

There is no silver bullet. It's born in a world of single-instance big fat application servers. It hardly fits into a modern world of:

functional programming: e.g. immutable threadsafe pojos / data classes
CQRS and eventsourcing
horizontal scaling of polyglot microservices

Make up your mind ...

How hibernate ruined Monica's career: https://www.toptal.com/java/how-hibernate-ruined-my-career
Why do I hate hibernate: https://de.slideshare.net/alimenkou/why-do-i-hate-hibernate-12998784
ORM is an antipattern: http://seldo.com/weblog/2011/08/11/orm_is_an_antipattern
Opinionated JPA: https://leanpub.com/opinionatedjpa/read
Lightweight ORM, do it yourself: https://blog.philipphauer.de/do-it-yourself-orm-alternative-hibernate-drawbacks/
Don't use H2 db for testing, use docker: https://blog.philipphauer.de/dont-use-in-memory-databases-tests-h2/

alexeybrod / spring-kotlin-exposed