Spring Webflux + Kotlin Coroutine + Spring Data R2DBC

SpringCoroutineApp.kt

package com.spring.coroutine

import io.r2dbc.spi.ConnectionFactory
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.support.beans
import org.springframework.core.io.ClassPathResource
import org.springframework.data.annotation.Id
import org.springframework.data.r2dbc.connectionfactory.init.CompositeDatabasePopulator
import org.springframework.data.r2dbc.connectionfactory.init.ConnectionFactoryInitializer
import org.springframework.data.r2dbc.connectionfactory.init.ResourceDatabasePopulator
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories
import org.springframework.data.relational.core.mapping.Table
import org.springframework.data.repository.kotlin.CoroutineCrudRepository
import org.springframework.web.reactive.function.server.*

@Table("users")
data class User(
        @Id val username: String,
        val name: String,
        val password: String
)

interface UserRepository : CoroutineCrudRepository<User, String>

data class SignUpRequest(
        val name: String,
        val username: String,
        val password: String
)

class AuthHandler(private val userRepository: UserRepository) {

    suspend fun signUp(request: ServerRequest): ServerResponse {
        val signUpRequest = request.awaitBody<SignUpRequest>()

        val existUser = userRepository.findById(signUpRequest.username)

        if (existUser != null) {
            return ServerResponse.status(500)
                    .bodyValueAndAwait("${signUpRequest.username} already exist")
        }

        val newUser = userRepository.save(
                AuthUser(name = signUpRequest.name,
                        username = signUpRequest.username,
                        password = "TODO hash salt")
        )

        return ServerResponse.ok().bodyValueAndAwait(newUser)
    }
}

fun routes(authHandler: AuthHandler) = coRouter {
    POST("/sign-up", authHandler::signUp)
}

fun dataSourceInitializer(connectionFactory: ConnectionFactory): ConnectionFactoryInitializer {
    val initializer = ConnectionFactoryInitializer()
    initializer.setConnectionFactory(connectionFactory)
    val populator = CompositeDatabasePopulator()
    populator.addPopulators(ResourceDatabasePopulator(ClassPathResource("schema.sql")))
    initializer.setDatabasePopulator(populator)
    return initializer
}

fun initializers() = beans {
    bean { dataSourceInitializer(ref()) }
    bean { AuthHandler(ref()) }
    bean { routes(ref()) }
}

@SpringBootApplication
@EnableR2dbcRepositories
class Application

fun main(args: Array<String>) {
    runApplication<Application>(*args) {
        addInitializers(initializers())
    }
}