Flatten packages

Remove modules prefix

persistance/src/users/UserRepositoryImpl.kt

@@ -0,0 +1,42 @@
+package be.simplenotes.persistance.users
+
+import be.simplenotes.persistance.converters.UserConverter
+import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.types.PersistedUser
+import be.simplenotes.types.User
+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
+import javax.inject.Singleton
+
+@Singleton
+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) {
+                it.username to user.username
+                it.password to user.password
+            } as Int
+            PersistedUser(user.username, user.password, id)
+        } catch (e: SQLIntegrityConstraintViolationException) {
+            null
+        }
+    }
+
+    override fun find(username: String) = db.users.find { it.username eq username }
+        ?.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
+    override fun findAll() = db.from(Users).select(Users.id).map { it[Users.id]!! }
+}

persistance/src/users/Users.kt

@@ -0,0 +1,28 @@
+package be.simplenotes.persistance.users
+
+import me.liuwj.ktorm.database.Database
+import me.liuwj.ktorm.entity.Entity
+import me.liuwj.ktorm.entity.sequenceOf
+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)
+
+    override fun aliased(alias: String) = Users(alias)
+
+    val id = int("id").primaryKey().bindTo { it.id }
+    val username = varchar("username").bindTo { it.username }
+    val password = varchar("password").bindTo { it.password }
+}
+
+internal interface UserEntity : Entity<UserEntity> {
+    companion object : Entity.Factory<UserEntity>()
+
+    var id: Int
+    var username: String
+    var password: String
+}
+
+internal val Database.users get() = this.sequenceOf(Users, withReferences = false)