Implement comments feature for articles

src/articles/articles.model.ts

@@ -34,6 +34,9 @@ export const articleRelations = relations(articles, ({ one, many }) => ({
   favoritedBy: many(favoriteArticles, {
     relationName: 'favoriteArticle',
   }),
+  comments: many(comments, {
+    relationName: 'articleComments',
+  }),
 }));
 
 export const favoriteArticles = pgTable(
@@ -66,3 +69,29 @@ export const favoriteArticleRelations = relations(
     }),
   }),
 );
+
+export const comments = pgTable('comments', {
+  id: serial('id').primaryKey().notNull(),
+  body: text('body').notNull(),
+  articleId: integer('article_id')
+    .references(() => articles.id, { onDelete: 'cascade' })
+    .notNull(),
+  authorId: integer('author_id')
+    .references(() => users.id, { onDelete: 'cascade' })
+    .notNull(),
+  createdAt: timestamp('created_at').default(sql`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp('updated_at').default(sql`CURRENT_TIMESTAMP`).notNull(),
+});
+
+export const commentRelations = relations(comments, ({ one }) => ({
+  article: one(articles, {
+    fields: [comments.articleId],
+    references: [articles.id],
+    relationName: 'articleComments',
+  }),
+  author: one(users, {
+    fields: [comments.authorId],
+    references: [users.id],
+    relationName: 'commentAuthor',
+  }),
+}));

src/articles/articles.module.ts

@@ -1,3 +1,5 @@
+import { CommentsRepository } from '@/articles/comments/comments.repository';
+import { CommentsService } from '@/articles/comments/comments.service';
 import { db } from '@/database.providers';
 import { ArticlesRepository } from '@articles/articles.repository';
 import { ArticlesService } from '@articles/articles.service';
@@ -9,6 +11,7 @@ import { Elysia } from 'elysia';
 
 export const setupArticles = () => {
   const articlesRepository = new ArticlesRepository(db);
+  const commentsRepository = new CommentsRepository(db);
   const profilesRepository = new ProfilesRepository(db);
   const usersRepository = new UsersRepository(db);
   const profilesService = new ProfilesService(
@@ -19,6 +22,15 @@ export const setupArticles = () => {
     articlesRepository,
     profilesService,
   );
+  const commentsService = new CommentsService(
+    commentsRepository,
+    profilesService,
+    usersRepository,
+  );
   const authService = new AuthService();
-  return new Elysia().state(() => ({ articlesService, authService }));
+  return new Elysia().state(() => ({
+    articlesService,
+    authService,
+    commentsService,
+  }));
 };

src/articles/articles.plugin.ts

@@ -8,7 +8,13 @@ import {
   ReturnedArticleResponseSchema,
   UpdateArticleSchema,
 } from '@articles/articles.schema';
-import { Elysia } from 'elysia';
+import { Elysia, t } from 'elysia';
+import {
+  AddCommentSchema,
+  DeleteCommentResponse,
+  ReturnedCommentResponse,
+  ReturnedCommentsResponse,
+} from './comments/comments.schema';
 
 export const articlesPlugin = new Elysia().use(setupArticles).group(
   '/articles',
@@ -67,7 +73,7 @@ export const articlesPlugin = new Elysia().use(setupArticles).group(
           query: ArticleFeedQuerySchema,
           response: ReturnedArticleListSchema,
           detail: {
-            summary: 'Artifle Feed',
+            summary: 'Article Feed',
           },
         },
       )
@@ -113,5 +119,72 @@ export const articlesPlugin = new Elysia().use(setupArticles).group(
             summary: 'Delete Article',
           },
         },
+      )
+      .post(
+        '/:slug/comments',
+        async ({ body, params, store, request }) => {
+          const comment = await store.commentsService.createComment(
+            params.slug,
+            body.comment,
+            await store.authService.getUserIdFromHeader(request.headers),
+          );
+          return { comment };
+        },
+        {
+          beforeHandle: app.store.authService.requireLogin,
+          params: t.Object({
+            slug: t.String(),
+          }),
+          body: AddCommentSchema,
+          response: ReturnedCommentResponse,
+          detail: {
+            summary: 'Add Comment to Article',
+          },
+        },
+      )
+      .get(
+        '/:slug/comments',
+        async ({ params, store, request }) => {
+          const userId = await store.authService.getOptionalUserIdFromHeader(
+            request.headers,
+          );
+          return {
+            comments: await store.commentsService.getComments(
+              params.slug,
+              userId === null ? undefined : userId,
+            ),
+          };
+        },
+        {
+          params: t.Object({
+            slug: t.String(),
+          }),
+          response: ReturnedCommentsResponse,
+          detail: {
+            summary: 'Get Comments from Article',
+          },
+        },
+      )
+      .delete(
+        '/:slug/comments/:id',
+        async ({ params, store, request }) => {
+          await store.commentsService.deleteComment(
+            params.slug,
+            Number.parseInt(params.id, 10),
+            await store.authService.getUserIdFromHeader(request.headers),
+          );
+          return {};
+        },
+        {
+          beforeHandle: app.store.authService.requireLogin,
+          params: t.Object({
+            slug: t.String(),
+            id: t.String(),
+          }),
+          response: DeleteCommentResponse,
+          detail: {
+            summary: 'Delete Comment',
+          },
+        },
       ),
 );

src/articles/articles.schema.ts

@@ -1,7 +1,6 @@
 import type { Profile } from '@profiles/profiles.schema';
 import { type Static, Type } from '@sinclair/typebox';
 import { createInsertSchema, createSelectSchema } from 'drizzle-typebox';
-// Do not use path aliases here (i.e. '@/users/users.model'), as that doesn't work with Drizzle Studio
 import { articles, type favoriteArticles } from './articles.model';
 
 export const insertArticleSchemaRaw = createInsertSchema(articles);
@@ -71,7 +70,7 @@ export type ArticleInDb = Omit<
   favoritedBy: ArticleFavoritedBy[];
 };
 
-type ArticleFavoritedBy = typeof favoriteArticles.$inferSelect;
+export type ArticleFavoritedBy = typeof favoriteArticles.$inferSelect;
 
 export const ArticleFeedQuerySchema = Type.Object({
   limit: Type.Optional(Type.Number({ minimum: 1, default: 20 })),

src/articles/comments/comments.repository.ts

@@ -0,0 +1,71 @@
+import type { Database } from '@/database.providers';
+import { articles, comments } from '@articles/articles.model';
+import { and, desc, eq } from 'drizzle-orm';
+import type { CommentToCreate } from './comments.schema';
+
+export class CommentsRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(commentData: CommentToCreate) {
+    const [comment] = await this.db
+      .insert(comments)
+      .values(commentData)
+      .returning();
+    return comment;
+  }
+
+  /**
+   * Find a comment by its id
+   * @param id - The id of the comment
+   * @returns The comment
+   */
+  async findById(id: number) {
+    const result = await this.db.query.comments.findFirst({
+      where: eq(comments.id, id),
+    });
+    return result;
+  }
+
+  /**
+   * Find all comments by article id
+   *
+   * Note: this operation is optimized to include the author and their followers.
+   * Use it with caution. If you need something simpler, consider refactoring this method and making the "with" option dynamic.
+   * @param articleId - The id of the article
+   * @returns An array of comments
+   */
+  async findManyByArticleId(articleId: number) {
+    const result = await this.db.query.comments.findMany({
+      where: eq(comments.articleId, articleId),
+      orderBy: [desc(comments.createdAt)],
+      with: {
+        author: {
+          columns: {
+            id: true,
+            username: true,
+            bio: true,
+            image: true,
+          },
+          with: {
+            followers: true,
+          },
+        },
+      },
+    });
+    return result;
+  }
+
+  async findBySlug(slug: string) {
+    const result = await this.db.query.articles.findFirst({
+      where: eq(articles.slug, slug),
+    });
+
+    return result;
+  }
+
+  async delete(commentId: number, authorId: number) {
+    return await this.db
+      .delete(comments)
+      .where(and(eq(comments.id, commentId), eq(comments.authorId, authorId)));
+  }
+}

src/articles/comments/comments.schema.ts

@@ -0,0 +1,48 @@
+import { selectUserSchemaRaw } from '@/users/users.schema';
+import { comments } from '@articles/articles.model';
+import { type Static, Type } from '@sinclair/typebox';
+import { createInsertSchema, createSelectSchema } from 'drizzle-typebox';
+
+export const insertCommentSchemaRaw = createInsertSchema(comments);
+export const selectCommentSchemaRaw = createSelectSchema(comments);
+
+export const AddCommentSchema = Type.Object({
+  comment: Type.Object({
+    body: Type.String(),
+  }),
+});
+
+export type CommentToCreate = Static<typeof AddCommentSchema>['comment'] & {
+  authorId: number;
+  articleId: number;
+};
+
+export const ReturnedCommentSchema = Type.Composite([
+  Type.Omit(selectCommentSchemaRaw, ['articleId', 'authorId']),
+  Type.Object({
+    author: Type.Composite([
+      Type.Omit(selectUserSchemaRaw, [
+        'id',
+        'email',
+        'password',
+        'createdAt',
+        'updatedAt',
+      ]),
+      Type.Object({
+        following: Type.Boolean(),
+      }),
+    ]),
+  }),
+]);
+
+export type ReturnedComment = Static<typeof ReturnedCommentSchema>;
+
+export const ReturnedCommentResponse = Type.Object({
+  comment: ReturnedCommentSchema,
+});
+
+export const ReturnedCommentsResponse = Type.Object({
+  comments: Type.Array(ReturnedCommentSchema),
+});
+
+export const DeleteCommentResponse = Type.Object({});