Merge branch 'main' into beta5

Author: nomisRev

src/main/kotlin/io/github/nomisrev/env/Dependencies.kt

@@ -31,7 +31,8 @@ suspend fun ResourceScope.dependencies(env: Env): Dependencies {
   val hikari = hikari(env.dataSource)
   val sqlDelight = sqlDelight(hikari)
   val userRepo = userPersistence(sqlDelight.usersQueries, sqlDelight.followingQueries)
-  val articleRepo = articleRepo(sqlDelight.articlesQueries, sqlDelight.tagsQueries)
+  val articleRepo =
+    articleRepo(sqlDelight.articlesQueries, sqlDelight.commentsQueries, sqlDelight.tagsQueries)
   val tagPersistence = tagPersistence(sqlDelight.tagsQueries)
   val favouritePersistence = favouritePersistence(sqlDelight.favoritesQueries)
   val jwtService = jwtService(env.auth, userRepo)

src/main/kotlin/io/github/nomisrev/repo/ArticlePersistence.kt

@@ -11,6 +11,8 @@ import io.github.nomisrev.routes.Profile
 import io.github.nomisrev.service.Slug
 import io.github.nomisrev.sqldelight.Articles
 import io.github.nomisrev.sqldelight.ArticlesQueries
+import io.github.nomisrev.sqldelight.Comments
+import io.github.nomisrev.sqldelight.CommentsQueries
 import io.github.nomisrev.sqldelight.TagsQueries
 import java.time.OffsetDateTime
 
@@ -37,9 +39,19 @@ interface ArticlePersistence {
   suspend fun getFeed(userId: UserId, limit: FeedLimit, offset: FeedOffset): List<Article>
 
   suspend fun getArticleBySlug(slug: Slug): Either<ArticleBySlugNotFound, Articles>
+
+  suspend fun insertCommentForArticleSlug(
+    slug: Slug,
+    userId: UserId,
+    comment: String,
+    articleId: ArticleId,
+    createdAt: OffsetDateTime,
+  ): Comments
+
+  suspend fun getCommentsForSlug(slug: Slug): List<SelectForSlug>
 }
 
-fun articleRepo(articles: ArticlesQueries, tagsQueries: TagsQueries) =
+fun articleRepo(articles: ArticlesQueries, comments: CommentsQueries, tagsQueries: TagsQueries) =
   object : ArticlePersistence {
     override suspend fun create(
       authorId: UserId,
@@ -108,4 +120,35 @@ fun articleRepo(articles: ArticlesQueries, tagsQueries: TagsQueries) =
         val article = articles.selectBySlug(slug.value).executeAsOneOrNull()
         ensureNotNull(article) { ArticleBySlugNotFound(slug.value) }
       }
+
+    override suspend fun getCommentsForSlug(slug: Slug): List<SelectForSlug> =
+      comments.selectForSlug(slug.value).executeAsList()
+
+    override suspend fun insertCommentForArticleSlug(
+      slug: Slug,
+      userId: UserId,
+      comment: String,
+      articleId: ArticleId,
+      createdAt: OffsetDateTime,
+    ) =
+      comments.transactionWithResult {
+        comments
+          .insertAndGetComment(
+            article_id = articleId.serial,
+            body = comment,
+            author = userId.serial,
+            createdAt = createdAt,
+            updatedAt = createdAt
+          ) { id, article_id, body, author, createdAt, updatedAt ->
+            Comments(
+              id = id,
+              body = body,
+              author = author,
+              createdAt = createdAt,
+              updatedAt = updatedAt,
+              article_id = article_id
+            )
+          }
+          .executeAsOne()
+      }
   }

src/main/kotlin/io/github/nomisrev/routes/articles.kt

@@ -2,16 +2,19 @@ package io.github.nomisrev.routes
 
 import arrow.core.raise.either
 import io.github.nomisrev.auth.jwtAuth
+import io.github.nomisrev.repo.UserId
 import io.github.nomisrev.service.ArticleService
 import io.github.nomisrev.service.CreateArticle
 import io.github.nomisrev.service.JwtService
 import io.github.nomisrev.service.Slug
+import io.github.nomisrev.service.UserService
 import io.github.nomisrev.validate
 import io.ktor.http.HttpStatusCode
 import io.ktor.resources.Resource
 import io.ktor.server.request.receive
 import io.ktor.server.resources.get
 import io.ktor.server.resources.post
+import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import java.time.OffsetDateTime
 import kotlinx.serialization.KSerializer
@@ -51,6 +54,10 @@ data class MultipleArticlesResponse(
 
 @JvmInline @Serializable value class FeedLimit(val limit: Int)
 
+@Serializable data class NewComment(val body: String)
+
+@Serializable data class SingleCommentResponse(val comment: Comment)
+
 @Serializable
 data class Comment(
   val commentId: Long,
@@ -60,6 +67,8 @@ data class Comment(
   val author: Profile
 )
 
+@Serializable data class MultipleCommentsResponse(val comments: List<Comment>)
+
 @Serializable
 data class NewArticle(
   val title: String,
@@ -96,6 +105,9 @@ data class ArticleResource(val parent: RootResource = RootResource) {
 data class ArticlesResource(val parent: RootResource = RootResource) {
   @Resource("{slug}")
   data class Slug(val parent: ArticlesResource = ArticlesResource(), val slug: String)
+
+  @Resource("{slug}/comments")
+  data class Comments(val parent: ArticlesResource = ArticlesResource(), val slug: String)
 }
 
 fun Route.articleRoutes(
@@ -157,6 +169,53 @@ fun Route.articleRoutes(
   }
 }
 
+fun Route.commentRoutes(
+  userService: UserService,
+  articleService: ArticleService,
+  jwtService: JwtService
+) {
+  post<ArticlesResource.Comments> { slug ->
+    jwtAuth(jwtService) { (_, userId) ->
+      either {
+          val comments =
+            articleService
+              .insertCommentForArticleSlug(
+                slug = Slug(slug.slug),
+                userId = userId,
+                comment = call.receive<NewComment>().validate().bind().body,
+              )
+              .bind()
+          val userProfile = userService.getUser(UserId(comments.author)).bind()
+          SingleCommentResponse(
+            Comment(
+              commentId = comments.id,
+              createdAt = comments.createdAt,
+              updatedAt = comments.updatedAt,
+              body = comments.body,
+              author =
+                Profile(
+                  username = userProfile.username,
+                  bio = userProfile.bio,
+                  image = userProfile.image,
+                  following = false
+                )
+            )
+          )
+        }
+        .respond(HttpStatusCode.OK)
+    }
+  }
+}
+
+fun Route.commentRoutes(articleService: ArticleService, jwtService: JwtService) {
+  get<ArticlesResource.Comments> { slug ->
+    jwtAuth(jwtService) { (_, _) ->
+      val comments = articleService.getCommentsForSlug(Slug(slug.slug))
+      call.respond(MultipleCommentsResponse(comments))
+    }
+  }
+}
+
 private object OffsetDateTimeIso8601Serializer : KSerializer<OffsetDateTime> {
   override val descriptor: SerialDescriptor =
     PrimitiveSerialDescriptor("OffsetDateTime", PrimitiveKind.STRING)

src/main/kotlin/io/github/nomisrev/routes/root.kt

@@ -9,7 +9,9 @@ fun Application.routes(deps: Dependencies) = routing {
   userRoutes(deps.userService, deps.jwtService)
   tagRoutes(deps.tagPersistence)
   articleRoutes(deps.articleService, deps.jwtService)
+  commentRoutes(deps.userService, deps.articleService, deps.jwtService)
   profileRoutes(deps.userPersistence, deps.jwtService)
+  commentRoutes(deps.articleService, deps.jwtService)
 }
 
 @Resource("/api") data object RootResource

src/main/kotlin/io/github/nomisrev/service/ArticleService.kt

@@ -3,16 +3,19 @@ package io.github.nomisrev.service
 import arrow.core.Either
 import arrow.core.raise.either
 import io.github.nomisrev.DomainError
+import io.github.nomisrev.repo.ArticleId
 import io.github.nomisrev.repo.ArticlePersistence
 import io.github.nomisrev.repo.FavouritePersistence
 import io.github.nomisrev.repo.TagPersistence
 import io.github.nomisrev.repo.UserId
 import io.github.nomisrev.repo.UserPersistence
 import io.github.nomisrev.routes.Article
+import io.github.nomisrev.routes.Comment
 import io.github.nomisrev.routes.FeedLimit
 import io.github.nomisrev.routes.FeedOffset
 import io.github.nomisrev.routes.MultipleArticlesResponse
 import io.github.nomisrev.routes.Profile
+import io.github.nomisrev.sqldelight.Comments
 import java.time.OffsetDateTime
 
 data class CreateArticle(
@@ -38,6 +41,14 @@ interface ArticleService {
 
   /** Get article by Slug */
   suspend fun getArticleBySlug(slug: Slug): Either<DomainError, Article>
+
+  suspend fun insertCommentForArticleSlug(
+    slug: Slug,
+    userId: UserId,
+    comment: String
+  ): Either<DomainError, Comments>
+
+  suspend fun getCommentsForSlug(slug: Slug): List<Comment>
 }
 
 fun articleService(
@@ -117,4 +128,27 @@ fun articleService(
         articleTags
       )
     }
+
+    override suspend fun insertCommentForArticleSlug(slug: Slug, userId: UserId, comment: String) =
+      either {
+        val article = getArticleBySlug(slug).bind()
+        articlePersistence.insertCommentForArticleSlug(
+          slug,
+          userId,
+          comment,
+          ArticleId(article.articleId),
+          OffsetDateTime.now()
+        )
+      }
+
+    override suspend fun getCommentsForSlug(slug: Slug): List<Comment> =
+      articlePersistence.getCommentsForSlug(slug).map { comment ->
+        Comment(
+          comment.comment__id,
+          comment.comment__createdAt,
+          comment.comment__updatedAt,
+          comment.comment__body,
+          Profile(comment.author__username, comment.author__bio, comment.author__image, false)
+        )
+      }
   }

src/main/kotlin/io/github/nomisrev/validation.kt

@@ -15,6 +15,7 @@ import io.github.nomisrev.routes.ArticleResource
 import io.github.nomisrev.routes.FeedLimit
 import io.github.nomisrev.routes.FeedOffset
 import io.github.nomisrev.routes.NewArticle
+import io.github.nomisrev.routes.NewComment
 import io.github.nomisrev.service.GetFeed
 import io.github.nomisrev.service.Login
 import io.github.nomisrev.service.RegisterUser
@@ -163,6 +164,9 @@ fun NewArticle.validate(): Either<IncorrectInput, NewArticle> =
     )
     .mapLeft(::IncorrectInput)
 
+fun NewComment.validate(): Either<IncorrectInput, NewComment> =
+  body.validBody().map { NewComment(it) }.mapLeft(::IncorrectInput)
+
 const val MIN_FEED_LIMIT = 1
 const val MIN_FEED_OFFSET = 0
 

src/main/sqldelight/io/github/nomisrev/sqldelight/Comments.sq

@@ -9,9 +9,10 @@ CREATE TABLE IF NOT EXISTS comments(
     updatedAt VARCHAR(50) AS OffsetDateTime NOT NULL
 );
 
-insert:
+insertAndGetComment:
 INSERT INTO comments(article_id, body, author, createdAt, updatedAt)
-VALUES (:article_id, :body, :author, :createdAt, :updatedAt);
+VALUES (:article_id, :body, :author, :createdAt, :updatedAt)
+RETURNING id, article_id, body, author, createdAt, updatedAt;
 
 selectByArticleId:
 SELECT id, article_id, body, author, createdAt, updatedAt
@@ -21,3 +22,11 @@ WHERE article_id = :articleId;
 delete:
 DELETE FROM comments
 WHERE id = :id;
+
+selectForSlug:
+SELECT comments.id AS comment__id, comments.article_id AS comment__articleId, comments.body AS comment__body, comments.author AS comment__author, comments.createdAt AS comment__createdAt, comments.updatedAt  AS comment__updatedAt,
+users.username AS author__username, users.bio AS author__bio, users.image AS author__image
+FROM comments
+INNER JOIN articles ON comments.article_id = articles.id
+INNER JOIN users ON comments.author = users.id
+WHERE articles.slug = :slug;