{"id":13921,"date":"2019-12-30T12:35:34","date_gmt":"2019-12-30T11:35:34","guid":{"rendered":"https:\/\/medium.com\/p\/ab8e5c6de72d"},"modified":"2023-01-31T13:55:59","modified_gmt":"2023-01-31T12:55:59","slug":"announcing-krush%e2%80%8a-%e2%80%8aidiomatic-persistence-layer-for-kotlin-based-on-exposed","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2019\/12\/30\/announcing-krush%e2%80%8a-%e2%80%8aidiomatic-persistence-layer-for-kotlin-based-on-exposed\/","title":{"rendered":"Announcing Krush – idiomatic persistence layer for Kotlin, based on Exposed"},"content":{"rendered":"

TL;DR<\/strong><\/h3>\n

We’ve released a persistence library for Kotlin, you can find it on our Github<\/a>. It\u2019s a JPA-to-Exposed SQL DSL generator.<\/p>\n

The state of persistence in\u00a0Kotlin<\/h3>\n

One of the key decisions that helped Kotlin gain massive popularity was to reuse Java ecosystem instead of inventing it\u2019s own. This means that you can safely use Kotlin as a primary language for a project developed using any popular Java stack like Spring Boot and built with Java build tool like Maven. What this also means is that natural choice for persistence layer in Kotlin is Spring Data with JPA 3 with Hibernate as an implementation.<\/p>\n

However, JPA, which highly relies on mutable objects and dirty checking, may not look like pure Kotlin, which tries to embrace functional programming and immutability. The official Spring JPA guide<\/a> for Kotlin uses mutable classes and properties which is not really idiomatic for Kotlin where you want to use immutable data classes whenever it\u2019s possible. <\/p>\n

Big update of the official @SpringBoot<\/a> + @Kotlin<\/a> tutorial: – #Mockk instead of Mockito – Follows @jbnizet<\/a> JPA guidelines (var instead of val, no data class) – Maven + Gradle build – Nullable instead of Optional for CrudRepository – Spring Boot 2.1.3 https:\/\/t.co\/B02Y8TugQf<\/a><\/p>\n

\u2014\u200a@sdeleuze<\/a><\/p><\/blockquote>\n

There are some other options, which can be used safely with Kotlin and data classes, like Spring Data JDBC<\/a>\u200a\u2014\u200ainteresting approach based on pure JDBC, embracing DDD and aggregate root concepts or Micronaut Data JDBC<\/a>\u200a\u2014\u200aif you\u2019re not tied to Spring ecosystem. But they\u2019re both relatively new, not mature yet and miss another idiomatic Kotlin feature\u200a\u2014\u200aa DSL for making SQL\u00a0queries.<\/p>\n

DSL for SQL\u00a0queries<\/h3>\n

Another thing that made Kotlin really powerful and popular is its ability to construct Domain Specific Languages using features like property reference, operators, infix and extension functions. For example, for Android development there is excellent anko<\/a> library for constructing complex view layouts for Android apps. In Spring\/JPA the default approach to SQL queries are query methods<\/a>, where you use special naming convention of methods in repository interfaces. The method names are parsed at runtime to provide required SQL queries and mapping. The naming convention is supported by IntelliJ Idea and other IDEs and works well in simple cases, but may be not flexible enough when you want complex queries e.g. with some conditions based on dynamic filters. If you want to use a true, type-safe, composable and idiomatic Kotlin SQL DSL, you can try to use other libraries, like Requery<\/a> or\u00a0Exposed<\/a>.<\/p>\n

Requery<\/h3>\n

Requery<\/a> is a lightweight persistence library for Java and Kotlin with RxJava and Java 8 streams support. It uses annotations (both custom and JPA) to process your entities and generate some infrastructure code called\u00a0\u201cmodel\u201d.<\/p>\n

So given a Book interface:<\/p>\n

@Entity\r\n@Table(name = \"books\")\r\n\r\ninterface Book : Persistable {\r\n    @get:Key @get:Generated\r\n    val id: Long\r\n\r\n    val isbn: String\r\n    val author: String\r\n    val title: String\r\n\r\n    val publishDate: LocalDate\r\n}<\/pre>\n
 <\/p>\n
You can instantiate and persist it by using generated BookEntity class:<\/p>\n
\n
\/\/given\r\nval book = BookEntity().apply {\r\n    setIsbn(\"1449373321\")\r\n    setPublishDate(LocalDate.of(2017, Month.APRIL, 11))\r\n    setTitle(\"Designing Data-Intensive Applications\")\r\n    setAutor(\"Martin Kleppmann\")\r\n}\r\n\r\n\/\/ when\r\nval persistedBook = dataStore.insert(book)<\/pre>\n<\/figure>\n
And the use SQL DSL to fetch data and map the results back to entities:<\/p>\n
\n
\/\/ then\r\nval books = dataStore.select(Book::class).where(Book::id eq  book.id).get().toList()\r\n\r\nassertThat(books).containsExactly(persistedBook)<\/pre>\n<\/figure>\n
This was really close to our needs! We like the idea of having annotations on the entities combined with the rich SQL DSL. Also the RxJava bindings and lazy Kotlin sequences support looks promising. On the other side, there are few minor issues related to immutable classes\u00a0support:<\/p>\n