How to implement a Ktor microservice using Onion Architecture, persistence with exposed and coroutines

4. Domain

This is the place where entities and domain logic are going to be placed.

                                
data class User(val id: Long?, val name: String, val email: String)
                                
                            

5. Repository

This layer abstracts the data store and enables you to replace your database without changing your business code, for the benefit parallelism we use suspend functions to allow coroutines to work

                                
interface UserRepository {
    suspend fun findAll(): List
    suspend fun findById(id: Long): User?
    suspend fun save(user: User): Unit
    suspend fun update(user: User): Unit
    suspend fun deleteById(id: Long): Unit
}

                                
                            

6. Infrastructure

This is the integration layer that implements database operations, clients, and business-to-business integration.

                                
import com.thesampleapp.domain.User
import com.thesampleapp.domain.UserRepository
import com.thesampleapp.infra.DatabaseFactory.dbQuery
import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import io.ktor.server.config.*
import org.jetbrains.exposed.sql.Table
import kotlinx.coroutines.*
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
import org.jetbrains.exposed.sql.transactions.*
import org.jetbrains.exposed.sql.transactions.experimental.*

object Users : Table() {
    val id = long("id").autoIncrement()
    val name = varchar("name", 100)
    val email = varchar("email", 200)
    override val primaryKey = PrimaryKey(id)
}


object DatabaseFactory {
    fun init(config: ApplicationConfig) {
        val driverClassName = config.property("database.driverClassName").getString()
        val jdbcURL = config.property("database.url").getString()
        val username = config.property("database.username").getString()
        val password = config.property("database.password").getString()
        val database = Database.connect(
            createHikariDataSource(
                url = jdbcURL,
                driver = driverClassName,
                aUsername = username,
                aPassword = password
            )
        )
        transaction(database) {
            SchemaUtils.create(Users)
        }
    }

    private fun createHikariDataSource(
        url: String,
        driver: String,
        aUsername: String,
        aPassword: String,
    ) = HikariDataSource(HikariConfig().apply {
        driverClassName = driver
        jdbcUrl = url
        username = aUsername
        password = aPassword
        maximumPoolSize = 3
        isAutoCommit = false
        transactionIsolation = "TRANSACTION_REPEATABLE_READ"
        validate()
    })


    suspend fun  dbQuery(block: suspend () -> T): T =
        newSuspendedTransaction(Dispatchers.IO) { block() }
}

class UserRepositoryImpl : UserRepository {
    private fun resultRowToArticle(row: ResultRow) = User(
        id = row[Users.id],
        name = row[Users.name],
        email = row[Users.email],
    )

    override suspend fun findAll(): List = dbQuery {
        Users.selectAll().map(::resultRowToArticle)
    }

    override suspend fun findById(id: Long): User? = dbQuery {
        Users.select { Users.id eq id }.map(::resultRowToArticle).singleOrNull()
    }

    override suspend fun save(user: User) {
        dbQuery {
            val insertStatement = Users.insert {
                it[name] = user.name
                it[email] = user.email
            }
            insertStatement.resultedValues?.singleOrNull()?.let(::resultRowToArticle)
        }
    }

    override suspend fun update(user: User) {
        user.id?.let { id ->
            Users.update({ Users.id eq id }) {
                it[name] = name
                it[email] = email
            } > 0
        }
    }

    override suspend fun deleteById(id: Long) {
        dbQuery {
            Users.deleteWhere { Users.id eq id } > 0
        }
    }

}

val userRepository: UserRepository = UserRepositoryImpl().apply {}
                                
                            

7. HTTP Routes

Routing is the core Ktor plugin for handling incoming HTTP requests in a server application. When the client makes a request to a specific URL (for example, /hello), the routing mechanism allows us to define how we want this request to be served.

                                
import com.thesampleapp.domain.User
import com.thesampleapp.infra.userRepository
import io.ktor.http.*
import io.ktor.server.routing.*
import io.ktor.server.response.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.util.*

fun Application.configureUserRouting() {
    routing {
        route("users"){
            get("{id}") {
                val id = call.parameters.getOrFail("id").toLong()
                val user =
                    userRepository.findById(id) ?: return@get call.respondText(
                        "No customer with id $id",
                        status = HttpStatusCode.NotFound
                    )
                call.respond(user)
            }
            put("{id}"){
                val id = call.parameters.getOrFail("id").toLong()
                val formParameters = call.receiveParameters()
                val name = formParameters.getOrFail("name")
                val email = formParameters.getOrFail("email")
                userRepository.update(user = User(id = id, name = name, email = email))
                call.respond(HttpStatusCode.NoContent)
            }
            delete("{id}") {
                val id = call.parameters.getOrFail("id").toLong()
                userRepository.deleteById(id)
                call.respond(HttpStatusCode.NoContent)
            }
            post{
                val formParameters = call.receiveParameters()
                val name = formParameters.getOrFail("name")
                val email = formParameters.getOrFail("email")
                userRepository.save(user = User(id=null,name = name, email = email))
                call.respond(HttpStatusCode.NoContent)
            }
        }
    }
}

                                
                            

8. Configuration

Ktor allows you to configure various server parameters, such as a host address and port, modules to load, and so on. The configuration depends on the way you used to create a server.

Ktor loads its configuration from a configuration file that uses the HOCON or YAML format

                                
ktor {
    deployment {
        port = 8080
        port = ${?PORT}
    }
    application {
        modules = [ com.thesampleapp.ApplicationKt.module ]
    }
}
database {
    driverClassName = "org.h2.Driver"
    url = "jdbc:h2:mem:db;DB_CLOSE_DELAY=-1"
    username = "sa"
    password = "sa"
}

                                
                            

9. Start the Application

To deliver a Ktor server application as a self-contained package, you need to create a server first. Server configuration can include different settings: a server engine (such as Netty, Jetty, etc.), various engine-specific options, host and port values, and so on. There are two main approaches in Ktor for creating and running a server:

• The embeddedServer function is a simple way to configure server parameters in code and quickly run an application.
• EngineMain provides more flexibility to configure a server. You can specify server parameters in a file and change a configuration without recompiling your application. Moreover, you can run your application from a command line and override the required server parameters by passing corresponding command-line arguments.

                                

import com.thesampleapp.plugins.configureUserRouting
import com.thesampleapp.plugins.configureSerialization
import io.ktor.server.application.*

fun main(args: Array): Unit = io.ktor.server.netty.EngineMain.main(args)

fun Application.module() {
    configureSerialization()
    configureUserRouting()
}