Use mapstruct

persistance/pom.xml

@@ -11,6 +11,10 @@
     <artifactId>persistance</artifactId>
 
     <dependencies>
+        <dependency>
+            <groupId>org.mapstruct</groupId>
+            <artifactId>mapstruct</artifactId>
+        </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
             <artifactId>domain</artifactId>

persistance/src/main/kotlin/PersistanceModule.kt

@@ -2,6 +2,10 @@ package be.simplenotes.persistance
 
 import be.simplenotes.domain.usecases.repositories.NoteRepository
 import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.persistance.converters.NoteConverter
+import be.simplenotes.persistance.converters.NoteConverterImpl
+import be.simplenotes.persistance.converters.UserConverter
+import be.simplenotes.persistance.converters.UserConverterImpl
 import be.simplenotes.persistance.notes.NoteRepositoryImpl
 import be.simplenotes.persistance.users.UserRepositoryImpl
 import be.simplenotes.shared.config.DataSourceConfig
@@ -30,8 +34,10 @@ val migrationModule = module {
 }
 
 val persistanceModule = module {
-    single<UserRepository> { UserRepositoryImpl(get()) }
+    single<NoteConverter> { NoteConverterImpl() }
-    single<NoteRepository> { NoteRepositoryImpl(get()) }
+    single<UserConverter> { UserConverterImpl() }
+    single<UserRepository> { UserRepositoryImpl(get(), get()) }
+    single<NoteRepository> { NoteRepositoryImpl(get(), get()) }
     single { hikariDataSource(get()) } bind DataSource::class onClose { it?.close() }
     single {
         get<DbMigrations>().migrate()

persistance/src/main/kotlin/converters/NoteConverter.kt

@@ -0,0 +1,80 @@
+package be.simplenotes.persistance.converters
+
+import be.simplenotes.domain.model.*
+import be.simplenotes.persistance.notes.NoteEntity
+import me.liuwj.ktorm.entity.Entity
+import org.mapstruct.Mapper
+import org.mapstruct.Mapping
+import org.mapstruct.Mappings
+import java.time.LocalDateTime
+import java.util.*
+
+
+/**
+ * This is an abstract class because kotlin default methods in interface are not seen as default in kapt
+ * @see [KT-25960](https://youtrack.jetbrains.com/issue/KT-25960)
+ */
+@Mapper(uses = [NoteEntityFactory::class, UserEntityFactory::class])
+internal abstract class NoteConverter {
+
+    fun toNote(entity: NoteEntity, tags: Tags) =
+        Note(NoteMetadata(title = entity.title, tags = tags), entity.markdown, entity.html)
+
+    @Mappings(
+        Mapping(target = ".", source = "entity"),
+        Mapping(target = "tags", source = "tags"),
+    )
+    abstract fun toNoteMetadata(entity: NoteEntity, tags: Tags): NoteMetadata
+
+    @Mappings(
+        Mapping(target = ".", source = "entity"),
+        Mapping(target = "tags", source = "tags"),
+    )
+    abstract fun toPersistedNoteMetadata(entity: NoteEntity, tags: Tags): PersistedNoteMetadata
+
+    fun toPersistedNote(entity: NoteEntity, tags: Tags) = PersistedNote(
+        NoteMetadata(title = entity.title, tags = tags),
+        entity.markdown, entity.html, entity.updatedAt, entity.uuid, entity.public
+    )
+
+    @Mappings(
+        Mapping(target = ".", source = "entity"),
+        Mapping(target = "trash", source = "entity.deleted"),
+        Mapping(target = "tags", source = "tags"),
+    )
+    abstract fun toExportedNote(entity: NoteEntity, tags: Tags): ExportedNote
+
+    fun toEntity(note: Note, uuid: UUID, userId: Int, updatedAt: LocalDateTime) = NoteEntity {
+         this.title = note.meta.title
+         this.markdown = note.markdown
+         this.html = note.html
+         this.uuid = uuid
+         this.deleted = false
+         this.public = false
+         this.user.id = userId
+         this.updatedAt = updatedAt
+     }
+
+    @Mappings(
+        Mapping(target = ".", source = "note"),
+        Mapping(target = "updatedAt", source = "updatedAt"),
+        Mapping(target = "uuid", source = "uuid"),
+        Mapping(target = "public", constant = "false"),
+    )
+    abstract fun toPersistedNote(note: Note, updatedAt: LocalDateTime, uuid: UUID): PersistedNote
+
+    abstract fun toEntity(persistedNoteMetadata: PersistedNoteMetadata): NoteEntity
+
+    abstract fun toEntity(noteMetadata: NoteMetadata): NoteEntity
+
+    @Mapping(target = "title", source = "meta.title")
+    abstract fun toEntity(persistedNote: PersistedNote): NoteEntity
+
+    @Mapping(target = "deleted", source = "trash")
+    abstract fun toEntity(exportedNote: ExportedNote): NoteEntity
+
+}
+
+typealias Tags = List<String>
+
+internal class NoteEntityFactory : Entity.Factory<NoteEntity>()

persistance/src/main/kotlin/converters/UserConverter.kt

@@ -0,0 +1,17 @@
+package be.simplenotes.persistance.converters
+
+import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.domain.model.User
+import be.simplenotes.persistance.users.UserEntity
+import me.liuwj.ktorm.entity.Entity
+import org.mapstruct.Mapper
+
+@Mapper(uses = [UserEntityFactory::class])
+internal interface UserConverter {
+    fun toUser(userEntity: UserEntity): User
+    fun toPersistedUser(userEntity: UserEntity): PersistedUser
+    fun toEntity(user: User): UserEntity
+    fun toEntity(user: PersistedUser): UserEntity
+}
+
+internal class UserEntityFactory : Entity.Factory<UserEntity>()

persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt

@@ -5,6 +5,7 @@ import be.simplenotes.domain.model.Note
 import be.simplenotes.domain.model.PersistedNote
 import be.simplenotes.domain.model.PersistedNoteMetadata
 import be.simplenotes.domain.usecases.repositories.NoteRepository
+import be.simplenotes.persistance.converters.NoteConverter
 import me.liuwj.ktorm.database.Database
 import me.liuwj.ktorm.dsl.*
 import me.liuwj.ktorm.entity.*
@@ -12,7 +13,7 @@ import java.time.LocalDateTime
 import java.util.*
 import kotlin.collections.HashMap
 
-internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
+internal class NoteRepositoryImpl(private val db: Database, private val converter: NoteConverter) : NoteRepository {
 
     @Throws(IllegalArgumentException::class)
     override fun findAll(
@@ -20,7 +21,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
         limit: Int,
         offset: Int,
         tag: String?,
-        deleted: Boolean
+        deleted: Boolean,
     ): List<PersistedNoteMetadata> {
         require(limit > 0) { "limit should be positive" }
         require(offset >= 0) { "offset should not be negative" }
@@ -49,7 +50,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
 
         return notes.map { note ->
             val tags = tagsByUuid[note.uuid] ?: emptyList()
-            note.toPersistedMetadata(tags)
+            converter.toPersistedNoteMetadata(note, tags)
         }
     }
 
@@ -59,9 +60,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
 
     override fun create(userId: Int, note: Note): PersistedNote {
         val uuid = UUID.randomUUID()
-        val entity = note.toEntity(uuid, userId).apply {
+        val entity = converter.toEntity(note, uuid, userId, LocalDateTime.now())
-            this.updatedAt = LocalDateTime.now()
-        }
         db.notes.add(entity)
         db.batchInsert(Tags) {
             note.meta.tags.forEach { tagName ->
@@ -71,8 +70,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
                 }
             }
         }
-
+        return converter.toPersistedNote(entity, note.meta.tags)
-        return entity.toPersistedNote(note.meta.tags)
     }
 
     override fun find(userId: Int, uuid: UUID): PersistedNote? {
@@ -87,7 +85,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
             .where { Tags.noteUuid eq uuid }
             .map { it[Tags.name]!! }
 
-        return note.toPersistedNote(tags)
+        return converter.toPersistedNote(note, tags)
     }
 
     override fun update(userId: Int, uuid: UUID, note: Note): PersistedNote? {
@@ -115,14 +113,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
             }
         }
 
-        return PersistedNote(
+        return converter.toPersistedNote(note, now, uuid)
-            meta = note.meta,
-            markdown = note.markdown,
-            html = note.html,
-            updatedAt = now,
-            uuid = uuid,
-            public = false, // TODO
-        )
     }
 
     override fun delete(userId: Int, uuid: UUID, permanent: Boolean): Boolean {
@@ -168,14 +159,8 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
         val tagsByUuid = notes.tagsByUuid()
 
         return notes.map { note ->
-            ExportedNote(
+            val tags = tagsByUuid[note.uuid] ?: emptyList()
-                title = note.title,
+            converter.toExportedNote(note, tags)
-                tags = tagsByUuid[note.uuid] ?: emptyList(),
-                markdown = note.markdown,
-                html = note.html,
-                updatedAt = note.updatedAt,
-                trash = note.deleted,
-            )
         }
     }
 
@@ -189,7 +174,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
 
         return notes.map { note ->
             val tags = tagsByUuid[note.uuid] ?: emptyList()
-            note.toPersistedNote(tags)
+            converter.toPersistedNote(note, tags)
         }
     }
 
@@ -216,7 +201,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
             .where { Tags.noteUuid eq uuid }
             .map { it[Tags.name]!! }
 
-        return note.toPersistedNote(tags)
+        return converter.toPersistedNote(note, tags)
     }
 
     private fun List<NoteEntity>.tagsByUuid(): Map<UUID, List<String>> {

persistance/src/main/kotlin/notes/Notes.kt

@@ -2,15 +2,12 @@
 
 package be.simplenotes.persistance.notes
 
-import be.simplenotes.domain.model.Note
-import be.simplenotes.domain.model.NoteMetadata
-import be.simplenotes.domain.model.PersistedNote
-import be.simplenotes.domain.model.PersistedNoteMetadata
 import be.simplenotes.persistance.extensions.uuidBinary
 import be.simplenotes.persistance.users.UserEntity
 import be.simplenotes.persistance.users.Users
-import me.liuwj.ktorm.database.*
+import me.liuwj.ktorm.database.Database
-import me.liuwj.ktorm.entity.*
+import me.liuwj.ktorm.entity.Entity
+import me.liuwj.ktorm.entity.sequenceOf
 import me.liuwj.ktorm.schema.*
 import java.time.LocalDateTime
 import java.util.*
@@ -46,21 +43,3 @@ internal interface NoteEntity : Entity<NoteEntity> {
 
     var user: UserEntity
 }
-
-internal fun NoteEntity.toPersistedMetadata(tags: List<String>) = PersistedNoteMetadata(title, tags, updatedAt, uuid)
-
-internal fun NoteEntity.toPersistedNote(tags: List<String>) =
-    PersistedNote(NoteMetadata(title, tags), markdown, html, updatedAt, uuid, public)
-
-internal fun Note.toEntity(uuid: UUID, userId: Int): NoteEntity {
-    val note = this
-    return NoteEntity {
-        this.title = note.meta.title
-        this.markdown = note.markdown
-        this.html = note.html
-        this.uuid = uuid
-        this.deleted = false
-        this.public = false
-        this.user["id"] = userId
-    }
-}

persistance/src/main/kotlin/users/UserRepositoryImpl.kt

@@ -3,13 +3,14 @@ package be.simplenotes.persistance.users
 import be.simplenotes.domain.model.PersistedUser
 import be.simplenotes.domain.model.User
 import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.persistance.converters.UserConverter
 import me.liuwj.ktorm.database.Database
 import me.liuwj.ktorm.dsl.*
 import me.liuwj.ktorm.entity.any
 import me.liuwj.ktorm.entity.find
 import java.sql.SQLIntegrityConstraintViolationException
 
-internal class UserRepositoryImpl(private val db: Database) : UserRepository {
+internal class UserRepositoryImpl(private val db: Database, private val converter: UserConverter) : UserRepository {
     override fun create(user: User): PersistedUser? {
         return try {
             val id = db.insertAndGenerateKey(Users) {
@@ -22,8 +23,13 @@ internal class UserRepositoryImpl(private val db: Database) : UserRepository {
         }
     }
 
-    override fun find(username: String) = db.users.find { it.username eq username }?.toPersistedUser()
+    override fun find(username: String) = db.users.find { it.username eq username }
-    override fun find(id: Int) = db.users.find { it.id eq id }?.toPersistedUser()
+        ?.let { converter.toPersistedUser(it) }
+
+    override fun find(id: Int) = db.users.find { it.id eq id }?.let {
+        converter.toPersistedUser(it)
+    }
+
     override fun exists(username: String) = db.users.any { it.username eq username }
     override fun exists(id: Int) = db.users.any { it.id eq id }
     override fun delete(id: Int) = db.delete(Users) { it.id eq id } == 1

persistance/src/main/kotlin/users/Users.kt

@@ -1,9 +1,11 @@
 package be.simplenotes.persistance.users
 
-import be.simplenotes.domain.model.PersistedUser
+import me.liuwj.ktorm.database.Database
-import me.liuwj.ktorm.database.*
+import me.liuwj.ktorm.entity.Entity
-import me.liuwj.ktorm.entity.*
+import me.liuwj.ktorm.entity.sequenceOf
-import me.liuwj.ktorm.schema.*
+import me.liuwj.ktorm.schema.Table
+import me.liuwj.ktorm.schema.int
+import me.liuwj.ktorm.schema.varchar
 
 internal open class Users(alias: String?) : Table<UserEntity>("Users", alias) {
     companion object : Users(null)
@@ -18,11 +20,9 @@ internal open class Users(alias: String?) : Table<UserEntity>("Users", alias) {
 internal interface UserEntity : Entity<UserEntity> {
     companion object : Entity.Factory<UserEntity>()
 
-    val id: Int
+    var id: Int
     var username: String
     var password: String
 }
 
-internal fun UserEntity.toPersistedUser() = PersistedUser(username, password, id)
-
 internal val Database.users get() = this.sequenceOf(Users, withReferences = false)

persistance/src/test/kotlin/converters/NoteConverterTest.kt

@@ -0,0 +1,168 @@
+package be.simplenotes.persistance.converters
+
+import be.simplenotes.domain.model.*
+import be.simplenotes.persistance.notes.NoteEntity
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+import org.mapstruct.factory.Mappers
+import java.time.LocalDateTime
+import java.util.*
+
+internal class NoteConverterTest {
+
+    @Nested
+    @DisplayName("Entity -> Models")
+    inner class EntityToModels {
+
+        @Test
+        fun `convert NoteEntity to Note`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val entity = NoteEntity {
+                title = "title"
+                markdown = "md"
+                html = "html"
+            }
+            val tags = listOf("a", "b")
+            val note = converter.toNote(entity, tags)
+            val expectedNote = Note(NoteMetadata(
+                title = "title",
+                tags = tags,
+            ), markdown = "md", html = "html")
+            assertThat(note).isEqualTo(expectedNote)
+        }
+
+        @Test
+        fun `convert NoteEntity to ExportedNote`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val entity = NoteEntity {
+                title = "title"
+                markdown = "md"
+                html = "html"
+                updatedAt = LocalDateTime.MIN
+                deleted = true
+            }
+            val tags = listOf("a", "b")
+            val note = converter.toExportedNote(entity, tags)
+            val expectedNote = ExportedNote(
+                title = "title",
+                tags = tags,
+                markdown = "md",
+                html = "html",
+                updatedAt = LocalDateTime.MIN,
+                trash = true
+            )
+            assertThat(note).isEqualTo(expectedNote)
+        }
+
+        @Test
+        fun `convert NoteEntity to PersistedNoteMetadata`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val entity = NoteEntity {
+                uuid = UUID.randomUUID()
+                title = "title"
+                markdown = "md"
+                html = "html"
+                updatedAt = LocalDateTime.MIN
+                deleted = true
+            }
+            val tags = listOf("a", "b")
+            val note = converter.toPersistedNoteMetadata(entity, tags)
+            val expectedNote = PersistedNoteMetadata(
+                title = "title",
+                tags = tags,
+                updatedAt = LocalDateTime.MIN,
+                uuid = entity.uuid
+            )
+            assertThat(note).isEqualTo(expectedNote)
+        }
+
+    }
+
+    @Nested
+    @DisplayName("Models -> Entity")
+    inner class ModelsToEntity {
+
+        @Test
+        fun `convert Note to NoteEntity`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val note = Note(NoteMetadata("title", emptyList()), "md", "html")
+            val entity = converter.toEntity(note, UUID.randomUUID(), 2, LocalDateTime.MIN)
+
+            assertThat(entity)
+                .hasFieldOrPropertyWithValue("markdown", "md")
+                .hasFieldOrPropertyWithValue("html", "html")
+                .hasFieldOrPropertyWithValue("title", "title")
+                .hasFieldOrPropertyWithValue("uuid", entity.uuid)
+                .hasFieldOrPropertyWithValue("updatedAt", LocalDateTime.MIN)
+        }
+
+        @Test
+        fun `convert PersistedNoteMetadata to NoteEntity`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val persistedNoteMetadata =
+                PersistedNoteMetadata("title", emptyList(), LocalDateTime.MIN, UUID.randomUUID())
+            val entity = converter.toEntity(persistedNoteMetadata)
+
+            assertThat(entity)
+                .hasFieldOrPropertyWithValue("uuid", persistedNoteMetadata.uuid)
+                .hasFieldOrPropertyWithValue("updatedAt", persistedNoteMetadata.updatedAt)
+                .hasFieldOrPropertyWithValue("title", "title")
+        }
+
+        @Test
+        fun `convert NoteMetadata to NoteEntity`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val noteMetadata = NoteMetadata("title", emptyList())
+            val entity = converter.toEntity(noteMetadata)
+
+            assertThat(entity)
+                .hasFieldOrPropertyWithValue("title", "title")
+        }
+
+        @Test
+        fun `convert PersistedNote to NoteEntity`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val persistedNote = PersistedNote(
+                NoteMetadata("title", emptyList()),
+                markdown = "md",
+                html = "html",
+                updatedAt = LocalDateTime.MIN,
+                uuid = UUID.randomUUID(),
+                public = true
+            )
+            val entity = converter.toEntity(persistedNote)
+
+            assertThat(entity)
+                .hasFieldOrPropertyWithValue("title", "title")
+                .hasFieldOrPropertyWithValue("markdown", "md")
+                .hasFieldOrPropertyWithValue("uuid", persistedNote.uuid)
+                .hasFieldOrPropertyWithValue("updatedAt", persistedNote.updatedAt)
+                .hasFieldOrPropertyWithValue("deleted", false)
+                .hasFieldOrPropertyWithValue("public", true)
+        }
+
+        @Test
+        fun `convert ExportedNote to NoteEntity`() {
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+            val exportedNote = ExportedNote(
+                "title",
+                emptyList(),
+                markdown = "md",
+                html = "html",
+                updatedAt = LocalDateTime.MIN,
+                trash = true
+            )
+            val entity = converter.toEntity(exportedNote)
+
+            assertThat(entity)
+                .hasFieldOrPropertyWithValue("title", "title")
+                .hasFieldOrPropertyWithValue("markdown", "md")
+                .hasFieldOrPropertyWithValue("updatedAt", exportedNote.updatedAt)
+                .hasFieldOrPropertyWithValue("deleted", true)
+        }
+
+    }
+
+}

persistance/src/test/kotlin/converters/UserConverterTest.kt

@@ -0,0 +1,48 @@
+package be.simplenotes.persistance.converters
+
+import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.domain.model.User
+import be.simplenotes.persistance.users.UserEntity
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.mapstruct.factory.Mappers
+
+internal class UserConverterTest {
+
+    @Test
+    fun `convert UserEntity to User`() {
+        val converter = Mappers.getMapper(UserConverter::class.java)
+        val entity = UserEntity {
+            username = "test"
+            password = "test2"
+        }.apply {
+            this["id"] = 2
+        }
+        val user = converter.toUser(entity)
+        assertThat(user).isEqualTo(User("test", "test2"))
+    }
+
+    @Test
+    fun `convert UserEntity to PersistedUser`() {
+        val converter = Mappers.getMapper(UserConverter::class.java)
+        val entity = UserEntity {
+            username = "test"
+            password = "test2"
+        }.apply {
+            this["id"] = 2
+        }
+        val user = converter.toPersistedUser(entity)
+        assertThat(user).isEqualTo(PersistedUser("test", "test2", 2))
+    }
+
+    @Test
+    fun `convert User to UserEntity`() {
+        val converter = Mappers.getMapper(UserConverter::class.java)
+        val user = User("test", "test2")
+        val entity = converter.toEntity(user)
+
+        assertThat(entity)
+            .hasFieldOrPropertyWithValue("username", "test")
+            .hasFieldOrPropertyWithValue("password", "test2")
+    }
+}

persistance/src/test/kotlin/notes/NoteRepositoryImplTest.kt

@@ -4,12 +4,16 @@ import be.simplenotes.domain.model.*
 import be.simplenotes.domain.usecases.repositories.NoteRepository
 import be.simplenotes.domain.usecases.repositories.UserRepository
 import be.simplenotes.persistance.DbMigrations
+import be.simplenotes.persistance.converters.NoteConverter
 import be.simplenotes.persistance.migrationModule
 import be.simplenotes.persistance.persistanceModule
 import be.simplenotes.shared.config.DataSourceConfig
-import me.liuwj.ktorm.database.*
+import me.liuwj.ktorm.database.Database
-import me.liuwj.ktorm.dsl.*
+import me.liuwj.ktorm.dsl.eq
-import me.liuwj.ktorm.entity.*
+import me.liuwj.ktorm.entity.filter
+import me.liuwj.ktorm.entity.find
+import me.liuwj.ktorm.entity.mapColumns
+import me.liuwj.ktorm.entity.toList
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.flywaydb.core.Flyway
@@ -17,6 +21,7 @@ import org.junit.jupiter.api.*
 import org.junit.jupiter.api.parallel.ResourceLock
 import org.koin.dsl.koinApplication
 import org.koin.dsl.module
+import org.mapstruct.factory.Mappers
 import java.sql.SQLIntegrityConstraintViolationException
 import java.util.*
 import javax.sql.DataSource
@@ -186,10 +191,12 @@ internal class NoteRepositoryImplTest {
         fun `find an existing note`() {
             createNote(user1.id, "1", listOf("a", "b"))
 
+            val converter = Mappers.getMapper(NoteConverter::class.java)
+
             val note = db.notes.find { it.title eq "1" }!!
                 .let { entity ->
                     val tags = db.tags.filter { it.noteUuid eq entity.uuid }.mapColumns { it.name } as List<String>
-                    entity.toPersistedNote(tags)
+                    converter.toPersistedNote(entity, tags)
                 }
 
             assertThat(noteRepo.find(user1.id, note.uuid))

pom.xml

@@ -29,6 +29,8 @@
         <maven.compiler.source>${java.version}</maven.compiler.source>
         <maven.compiler.target>${java.version}</maven.compiler.target>
         <kotlin.compiler.jvmTarget>${java.version}</kotlin.compiler.jvmTarget>
+
+        <org.mapstruct.version>1.4.1.Final</org.mapstruct.version>
     </properties>
 
     <dependencies>
@@ -99,6 +101,21 @@
                 <groupId>org.jetbrains.kotlin</groupId>
                 <version>${kotlin.version}</version>
                 <executions>
+                    <execution>
+                        <id>kapt</id>
+                        <goals>
+                            <goal>kapt</goal>
+                        </goals>
+                        <configuration>
+                            <annotationProcessorPaths>
+                                <annotationProcessorPath>
+                                    <groupId>org.mapstruct</groupId>
+                                    <artifactId>mapstruct-processor</artifactId>
+                                    <version>${org.mapstruct.version}</version>
+                                </annotationProcessorPath>
+                            </annotationProcessorPaths>
+                        </configuration>
+                    </execution>
                     <execution>
                         <id>compile</id>
                         <phase>process-sources</phase>
@@ -181,6 +198,12 @@
                 <version>3.0.0</version>
             </dependency>
 
+            <dependency>
+                <groupId>org.mapstruct</groupId>
+                <artifactId>mapstruct</artifactId>
+                <version>${org.mapstruct.version}</version>
+            </dependency>
+
             <!-- region tests -->
             <dependency>
                 <groupId>org.junit.jupiter</groupId>