move ResultRow mappings to ext functions

build.gradle.kts

@@ -16,7 +16,7 @@ repositories {
     // Use jcenter for resolving your dependencies.
     // You can declare any Maven/Ivy/file repository here.
     jcenter()
-    maven (url="https://dl.bintray.com/pgutkowski/Maven")
+    maven (url="https://jitpack.io")
 }
 
 dependencies {
@@ -25,7 +25,7 @@ dependencies {
     implementation("org.jetbrains.exposed:exposed:0.11.2")
     implementation("org.http4k:http4k-core:3.102.0")
     implementation("org.postgresql:postgresql:42.2.2")
-    implementation("com.github.pgutkowski:kgraphql:0.3.0")
+    implementation("com.github.pabl0rg:kgraphql:e8dfd028478321325b7a323f46eab03f768c803a")
     implementation("org.http4k:http4k-server-jetty:3.102.0")
     // Use the Kotlin test library
     testImplementation("org.jetbrains.kotlin:kotlin-test")

src/main/kotlin/com/github/jmlb23/movielense/MovieLensService.kt

@@ -0,0 +1,36 @@
+package com.github.jmlb23.movielense
+
+import com.github.jmlb23.movielense.datasources.exposed.Users
+import com.github.jmlb23.movielense.domain.*
+import com.github.jmlb23.movielense.repositories.Repository
+import org.joda.time.DateTime
+
+class MovieLensService(private val movieRepo: Repository<Movie>,
+                       private val genreRepo: Repository<Genre>,
+                       private val occupationRepo: Repository<Occupation>,
+                       private val ratingRepo: Repository<Rating>,
+                       private val userRepo: Repository<User>) {
+
+    fun getAllUsers() = userRepo.getAll().toList()
+    fun getUser(id: Int) = userRepo.filter{ Users.id eq id }.toList().firstOrNull()
+
+    fun createUser(age: Int, gender: String, occupationId: Long, zipCode: String): User {
+        val newUser = User(0, age, gender.first().toGender(), occupationId, zipCode)
+        val newId = userRepo.add(newUser)
+        return newUser.copy(id = newId)
+    }
+
+    fun deleteUser(id: Long) = userRepo.remove(id)
+
+    fun updateUser(id: Long, age: Int, gender: String, occupationId: Long, zipCode: String): Long =
+            userRepo.replace(id, User(id=0,age = age,gender = gender.first().toGender(),occupationId = occupationId, zipCode = zipCode))
+
+    fun getAllRates() = ratingRepo.getAll().toList()
+    fun getRate(id: Int) = ratingRepo.getElement(id.toLong())
+    fun createRating(userId: Long, movieId: Long, rating: Int) = ratingRepo.add(Rating(userId,movieId,rating, DateTime.now().toDate()))
+    fun deleteRating(id: Int) = ratingRepo.remove(id.toLong())
+    fun updateRating(ratingId: Int, userId: Long, movieId: Long, rating: Int) =
+            ratingRepo.replace(ratingId.toLong(), Rating(userId,movieId,rating,DateTime.now().toDate()))
+
+
+}

src/main/kotlin/com/github/jmlb23/movielense/graphql/schema/schema.graphql.kt

@@ -1,80 +1,64 @@
 package com.github.jmlb23.movielense.graphql.schema
 
+import com.github.jmlb23.movielense.MovieLensService
 import com.github.jmlb23.movielense.datasources.exposed.Genres
 import com.github.jmlb23.movielense.datasources.exposed.Occupations
 import com.github.jmlb23.movielense.datasources.exposed.Ratings
-import com.github.jmlb23.movielense.datasources.exposed.Users
 import com.github.jmlb23.movielense.domain.*
-import com.github.jmlb23.movielense.repositories.GenresRepository
-import com.github.jmlb23.movielense.repositories.OccupationRepository
-import com.github.jmlb23.movielense.repositories.RatingRepository
-import com.github.jmlb23.movielense.repositories.UserRepository
+import com.github.jmlb23.movielense.repositories.*
 import com.github.pgutkowski.kgraphql.KGraphQL
+import com.github.pgutkowski.kgraphql.schema.model.FunctionWrapper
 import org.joda.time.DateTime
 
+val mlService = MovieLensService(MovieRepository, GenresRepository, OccupationRepository, RatingRepository, UserRepository)
+
 val schema = KGraphQL.schema{
     //users
     query("allUsers"){
-        resolver{ ->
-                UserRepository.getAll().toList()
-        }
+        mlService::getAllUsers.toResolver()
     }
 
     query("getUser"){
-        resolver{ id: Int ->
-            UserRepository.filter{Users.id eq id }.toList().firstOrNull()
-        }
+        mlService::getUser.toResolver()
+    }
+
+    query("getUserAndRatings"){
+        mlService::getUser.toResolver()
     }
 
     mutation("createUser"){
-        resolver{ age: Int, gender: String, occupationId: Long, zipCode: String ->
-            UserRepository.add(User(0,age,gender.first().toGender(),occupationId,zipCode))
-        }
+        mlService::createUser.toResolver()
     }
 
     mutation("deleteUser"){
-        resolver{id: Long ->
-            UserRepository.remove(id)
-        }
+        mlService::deleteUser.toResolver()
     }
 
     mutation("updateUser"){
-        resolver{id: Long, age: Int, gender: String, occupationId: Long, zipCode: String ->
-            val user = User(id=0,age = age,gender = gender.first().toGender(),occupationId = occupationId, zipCode = zipCode)
-            UserRepository.replace(id, user)
-        }
+        mlService::updateUser.toResolver()
     }
+
     //Rates
     query("allRates"){
-        resolver{
-            -> RatingRepository.getAll().toList()
-        }
+        mlService::getAllRates.toResolver()
     }
 
     query("getRate"){
-        resolver{ id: Int
-            -> RatingRepository.filter { Ratings.id eq id }.toList().first()
-        }
+        mlService::getRate.toResolver()
     }
 
     mutation("createRate"){
-        resolver{ userId: Long, movieId: Long, rating: Int ->
-            RatingRepository.add(Rating(userId,movieId,rating,DateTime.now().toDate()))
-        }
+        mlService::createRating.toResolver()
     }
 
     mutation("deleteRate"){
-        resolver{id: Int ->
-            RatingRepository.remove(id.toLong())
-        }
+        mlService::deleteRating.toResolver()
     }
 
     mutation("updateRate"){
-        resolver{ratingId: Int, userId: Long, movieId: Long, rating: Int ->
-            val rate = Rating(userId,movieId,rating,DateTime.now().toDate())
-            RatingRepository.replace(ratingId.toLong(),rate)
-        }
+        mlService::updateRating.toResolver()
     }
+
     //genres
     query("allGenres"){
         resolver{
@@ -132,7 +116,7 @@ val schema = KGraphQL.schema{
         }
     }
 
-    mutation("updateRate"){
+    mutation("updateOccupation"){
         resolver{occupationId: Long, name: String ->
             val rate = Occupation(0,name)
             OccupationRepository.replace(occupationId,rate)

src/main/kotlin/com/github/jmlb23/movielense/repositories/GenresRepository.kt

@@ -6,9 +6,10 @@ import com.github.jmlb23.movielense.domain.Genre
 import org.jetbrains.exposed.sql.*
 
 object GenresRepository : Repository<Genre>{
+    private fun ResultRow.toGenre() = Genre(this[Genres.id],this[Genres.name])
 
     override fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<Genre> = transactionEnviroment {
-        Genres.select(predicate).map{ Genre(it[Genres.id],it[Genres.name]) }
+        Genres.select(predicate).map{ it.toGenre() }
 
     }.asSequence()
 
@@ -22,7 +23,7 @@ object GenresRepository : Repository<Genre>{
     override fun getAll(): Sequence<Genre> = transactionEnviroment {
         Genres.selectAll()
                 .toList()
-                .map{ Genre(it[Genres.id],it[Genres.name])}
+                .map{ it.toGenre() }
     }.asSequence()
 
     override fun remove(indexer: Long): Long =
@@ -33,7 +34,7 @@ object GenresRepository : Repository<Genre>{
     override fun getElement(indexer: Long): Genre = transactionEnviroment {
         Genres
                 .select {Genres.id eq indexer.toInt()}
-                .map { x -> Genre(x[Genres.id],x[Genres.name]) }
+                .map { it.toGenre() }
                 .first()
     }
 

src/main/kotlin/com/github/jmlb23/movielense/repositories/MovieRepository.kt

@@ -7,8 +7,10 @@ import org.jetbrains.exposed.sql.*
 import org.joda.time.DateTime
 
 object MovieRepository : Repository<Movie>{
+    private fun ResultRow.toMovie()  = Movie(this[Movies.id].toLong(),this[Movies.title],this[Movies.releaseDate].toDate())
+
     override fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<Movie> = transactionEnviroment {
-        Movies.select(predicate).map{ Movie(it[Movies.id].toLong(),it[Movies.title],it[Movies.releaseDate].toDate())}
+        Movies.select(predicate).map{ it.toMovie() }
 
     }.asSequence()
 
@@ -24,7 +26,7 @@ object MovieRepository : Repository<Movie>{
             transactionEnviroment {
                 Movies.selectAll()
                         .toList()
-                        .map{ Movie(it[Movies.id].toLong(),it[Movies.title],it[Movies.releaseDate].toDate())}
+                        .map{ it.toMovie() }
             }.asSequence()
 
 
@@ -47,7 +49,7 @@ object MovieRepository : Repository<Movie>{
             transactionEnviroment {
                 Movies
                         .select {Movies.id eq indexer.toInt()}
-                        .map{ Movie(it[Movies.id].toLong(),it[Movies.title],it[Movies.releaseDate].toDate())}
+                        .map{ it.toMovie() }
                         .first()
             }
 }

src/main/kotlin/com/github/jmlb23/movielense/repositories/OccupationRepository.kt

@@ -6,10 +6,10 @@ import com.github.jmlb23.movielense.domain.Occupation
 import org.jetbrains.exposed.sql.*
 
 object OccupationRepository : Repository<Occupation>{
-
+    private fun ResultRow.toOccupation() = Occupation(this[Occupations.id].toLong(),this[Occupations.name])
 
     override fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<Occupation> = transactionEnviroment {
-        Occupations.select(predicate).map{ Occupation(it[Occupations.id].toLong(),it[Occupations.name])}
+        Occupations.select(predicate).map{ it.toOccupation() }
 
     }.asSequence()
 
@@ -24,7 +24,7 @@ object OccupationRepository : Repository<Occupation>{
         transactionEnviroment {
             Occupations.selectAll()
                     .toList()
-                    .map{ Occupation(it[Occupations.id].toLong(),it[Occupations.name])}
+                    .map{ it.toOccupation() }
         }.asSequence()
 
 
@@ -46,7 +46,7 @@ object OccupationRepository : Repository<Occupation>{
         transactionEnviroment {
             Occupations
                     .select {Occupations.id eq indexer.toInt()}
-                    .map { x -> Occupation(x[Occupations.id].toLong(),x[Occupations.name]) }
+                    .map { it.toOccupation() }
                     .first()
         }
 

src/main/kotlin/com/github/jmlb23/movielense/repositories/RatingRepository.kt

@@ -7,9 +7,10 @@ import org.jetbrains.exposed.sql.*
 import org.joda.time.DateTime
 
 object RatingRepository : Repository<Rating>{
+    private fun ResultRow.toRating() = Rating(this[Ratings.id].toLong(),this[Ratings.userId].toLong(),this[Ratings.movieId].toLong(),this[Ratings.rating],this[Ratings.ratedAt].toDate())
 
     override fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<Rating> = transactionEnviroment {
-        Ratings.select(predicate).map{ Rating(it[Ratings.id].toLong(),it[Ratings.userId].toLong(),it[Ratings.movieId].toLong(),it[Ratings.rating],it[Ratings.ratedAt].toDate())}
+        Ratings.select(predicate).map{ it.toRating() }
 
     }.asSequence()
 
@@ -27,7 +28,7 @@ object RatingRepository : Repository<Rating>{
         transactionEnviroment {
             Ratings.selectAll()
                     .toList()
-                    .map{ Rating(it[Ratings.id].toLong(),it[Ratings.userId].toLong(),it[Ratings.movieId].toLong(),it[Ratings.rating],it[Ratings.ratedAt].toDate())}
+                    .map{ it.toRating() }
         }.asSequence()
 
 
@@ -48,12 +49,12 @@ object RatingRepository : Repository<Rating>{
         }.toLong()
 
 
-    override fun getElement(indexer: Long): Rating =
+    override fun getElement(indexer: Long): Rating? =
         transactionEnviroment {
             Ratings
                     .select {Ratings.id eq indexer.toInt()}
-                    .map{ Rating(it[Ratings.id].toLong(),it[Ratings.userId].toLong(),it[Ratings.movieId].toLong(),it[Ratings.rating],it[Ratings.ratedAt].toDate())}
-                    .first()
+                    .map{ it.toRating() }
+                    .firstOrNull()
         }
 
 

src/main/kotlin/com/github/jmlb23/movielense/repositories/Repository.kt

@@ -9,6 +9,6 @@ interface Repository<D>{
     fun getAll(): Sequence<D>
     fun remove(indexer: Long): Long
     fun replace(indexer: Long, element: D): Long
-    fun getElement(indexer: Long): D
+    fun getElement(indexer: Long): D?
     fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<D>
 }

src/main/kotlin/com/github/jmlb23/movielense/repositories/UserRepository.kt

@@ -7,17 +7,17 @@ import com.github.jmlb23.movielense.domain.toGender
 import org.jetbrains.exposed.sql.*
 
 object UserRepository : Repository<User>{
-
+    private fun ResultRow.toUser() = User(this[Users.id].toLong(),this[Users.age],this[Users.gender].toGender(),this[Users.occupationId].toLong(),this[Users.zipCode].toString())
 
     override fun filter(predicate: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<User> = transactionEnviroment {
-        Users.select(predicate).map{ User(it[Users.id].toLong(),it[Users.age],it[Users.gender].toGender(),it[Users.occupationId].toLong(),it[Users.zipCode].toString())}
+        Users.select(predicate).map{ it.toUser() }
 
     }.asSequence()
 
     override fun add(element: User): Long =
             transactionEnviroment { Users.insert {
                 it[age]= element.age
-                it[gender] = element.gender.let { it.toString().first() }
+                it[gender] = element.gender.toString().first()
                 it[occupationId] = element.occupationId.toInt()
                 it[zipCode] = element.zipCode
             }.generatedKey!!.toLong()
@@ -28,7 +28,7 @@ object UserRepository : Repository<User>{
         transactionEnviroment {
             Users.selectAll()
                     .toList()
-                    .map{ User(it[Users.id].toLong(),it[Users.age],it[Users.gender].toGender(),it[Users.occupationId].toLong(),it[Users.zipCode].toString())}
+                    .map{ it.toUser() }
         }.asSequence()
 
 
@@ -53,7 +53,7 @@ object UserRepository : Repository<User>{
         transactionEnviroment {
             Users
                     .select {Users.id eq indexer.toInt()}
-                    .map { x -> User(x[Users.id].toLong(),x[Users.age],x[Users.gender].toGender(),x[Users.occupationId].toLong(),x[Users.zipCode].toString()) }
+                    .map { it.toUser() }
                     .first()
         }