Feat/comments

src/routes/v2/authenticated/review.ts

@@ -19,6 +19,7 @@ import UsersService from "@root/services/identity/UsersService"
 import { isIsomerError, RequestHandler } from "@root/types"
 import { ResponseErrorBody } from "@root/types/dto/error"
 import {
+  CommentItem,
   DashboardReviewRequestDto,
   EditedItemDto,
   UpdateReviewRequestDto,
@@ -634,6 +635,61 @@ export class ReviewsRouter {
     return res.status(200).send()
   }
 
+  getComments: RequestHandler<
+    { siteName: string; requestId: number },
+    CommentItem[],
+    never,
+    unknown,
+    { userWithSiteSessionData: UserWithSiteSessionData }
+  > = async (req, res) => {
+    const { siteName, requestId } = req.params
+    const { userWithSiteSessionData } = res.locals
+    // Step 1: Check that the site exists
+    const site = await this.sitesService.getBySiteName(siteName)
+    if (!site) {
+      logger.error({
+        message: "Invalid site requested",
+        method: "getComments",
+        meta: {
+          userId: userWithSiteSessionData.isomerUserId,
+          email: userWithSiteSessionData.email,
+          siteName,
+        },
+      })
+      return res.status(404).send({
+        message: "Please ensure that the site exists!",
+      })
+    }
+
+    // Step 2: Retrieve comments
+    const comments = await this.reviewRequestService.getComments(
+      userWithSiteSessionData,
+      site,
+      requestId
+    )
+
+    return res.status(200).json(comments)
+  }
+
+  createComment: RequestHandler<
+    { siteName: string; requestId: number },
+    string | ResponseErrorBody,
+    { message: string },
+    unknown,
+    { userWithSiteSessionData: UserWithSiteSessionData }
+  > = async (req, res) => {
+    const { requestId } = req.params
+    const { message } = req.body
+    const { userWithSiteSessionData } = res.locals
+    await this.reviewRequestService.createComment(
+      userWithSiteSessionData,
+      requestId,
+      message
+    )
+
+    return res.status(200).send("OK")
+  }
+
   markReviewRequestCommentsAsViewed: RequestHandler<
     { siteName: string; requestId: number },
     string | ResponseErrorBody,
@@ -794,8 +850,16 @@ export class ReviewsRouter {
       "/:requestId/approve",
       attachReadRouteHandlerWrapper(this.approveReviewRequest)
     )
+    router.get(
+      "/:requestId/comments",
+      attachWriteRouteHandlerWrapper(this.getComments)
+    )
+    router.post(
+      "/:requestId/comments",
+      attachWriteRouteHandlerWrapper(this.createComment)
+    )
     router.post(
-      "/:requestId/viewedComments",
+      "/:requestId/comments/viewedComments",
       attachWriteRouteHandlerWrapper(this.markReviewRequestCommentsAsViewed)
     )
     router.post(

src/services/db/GitHubService.js

@@ -51,6 +51,14 @@ class GitHubService {
     return ReviewApi.approvePullRequest(siteName, pullRequestNumber)
   }
 
+  async getComments(siteName, pullRequestNumber) {
+    return ReviewApi.getComments(siteName, pullRequestNumber)
+  }
+
+  async createComment(siteName, pullRequestNumber, user, message) {
+    return ReviewApi.createComment(siteName, pullRequestNumber, user, message)
+  }
+
   getFilePath({ siteName, fileName, directoryName }) {
     if (!directoryName)
       return `${siteName}/contents/${encodeURIComponent(fileName)}`

src/services/db/review.ts

@@ -1,4 +1,12 @@
-import { RawFileChangeInfo, Commit, RawPullRequest } from "@root/types/github"
+import _ from "lodash"
+
+import {
+  RawFileChangeInfo,
+  Commit,
+  RawPullRequest,
+  RawComment,
+  fromGithubCommitMessage,
+} from "@root/types/github"
 
 import { isomerRepoAxiosInstance as axiosInstance } from "../api/AxiosInstance"
 
@@ -83,3 +91,41 @@ export const approvePullRequest = (
       },
     }
   )
+
+export const getComments = async (
+  siteName: string,
+  pullRequestNumber: number
+) => {
+  const rawComments = await axiosInstance
+    .get<RawComment[]>(`${siteName}/issues/${pullRequestNumber}/comments`)
+    .then(({ data }) => data)
+  return _.compact(
+    rawComments.map((rawComment) => {
+      const commentData = fromGithubCommitMessage(rawComment.body)
+      if (_.isEmpty(commentData)) return null // Will be filtered out by _.compact
+      const { userId, message } = commentData
+      if (!userId || !message) return null // Will be filtered out by _.compact
+      return {
+        userId,
+        message,
+        createdAt: rawComment.created_at,
+      }
+    })
+  )
+}
+
+export const createComment = async (
+  siteName: string,
+  pullRequestNumber: number,
+  userId: string,
+  message: string
+) => {
+  const stringifiedMessage = JSON.stringify({
+    userId,
+    message,
+  })
+  return axiosInstance.post<void>(
+    `${siteName}/issues/${pullRequestNumber}/comments`,
+    { body: stringifiedMessage }
+  )
+}

src/services/review/ReviewRequestService.ts

@@ -12,6 +12,7 @@ import { Site } from "@root/database/models/Site"
 import { User } from "@root/database/models/User"
 import RequestNotFoundError from "@root/errors/RequestNotFoundError"
 import {
+  CommentItem,
   DashboardReviewRequestDto,
   EditedItemDto,
   FileType,
@@ -125,6 +126,29 @@ export default class ReviewRequestService {
     return mappings
   }
 
+  computeCommentDataMappings = async (
+    comments: {
+      userId: string
+      message: string
+      createdAt: string
+    }[],
+    viewedTime: Date | null
+  ) => {
+    const mappings = await Promise.all(
+      comments.map(async ({ userId, message, createdAt }) => {
+        const createdTime = new Date(createdAt)
+        const author = await this.users.findByPk(userId)
+        return {
+          user: author?.email || "",
+          message,
+          createdAt: createdTime.getTime(),
+          isRead: viewedTime ? createdTime < viewedTime : false,
+        }
+      })
+    )
+    return mappings
+  }
+
   createReviewRequest = async (
     sessionData: UserWithSiteSessionData,
     reviewers: User[],
@@ -455,4 +479,58 @@ export default class ReviewRequestService {
     reviewRequest.reviewStatus = ReviewRequestStatus.Merged
     return reviewRequest.save()
   }
+
+  createComment = async (
+    sessionData: UserWithSiteSessionData,
+    pullRequestNumber: number,
+    message: string
+  ) => {
+    const { siteName, isomerUserId } = sessionData
+
+    return this.apiService.createComment(
+      siteName,
+      pullRequestNumber,
+      isomerUserId,
+      message
+    )
+  }
+
+  getComments = async (
+    sessionData: UserWithSiteSessionData,
+    site: Site,
+    pullRequestNumber: number
+  ): Promise<CommentItem[]> => {
+    const { siteName, isomerUserId: userId } = sessionData
+
+    const comments = await this.apiService.getComments(
+      siteName,
+      pullRequestNumber
+    )
+
+    const requestsView = await this.reviewRequestView.findOne({
+      where: {
+        siteId: site.id,
+        userId,
+      },
+      include: [
+        {
+          model: ReviewRequest,
+          required: true,
+          include: [
+            {
+              model: ReviewMeta,
+              required: true,
+              where: {
+                pullRequestNumber,
+              },
+            },
+          ],
+        },
+      ],
+    })
+
+    const viewedTime = requestsView ? new Date(requestsView.lastViewedAt) : null
+
+    return this.computeCommentDataMappings(comments, viewedTime)
+  }
 }

src/types/dto/review.ts

@@ -44,3 +44,10 @@ export interface ReviewRequestDto {
 export interface UpdateReviewRequestDto {
   reviewers: string[]
 }
+
+export interface CommentItem {
+  user: string
+  createdAt: number
+  message: string
+  isRead: boolean
+}

src/types/github.ts

@@ -81,3 +81,8 @@ export interface RawPullRequest {
   changed_files: number
   created_at: string
 }
+
+export interface RawComment {
+  body: string
+  created_at: string
+}