feat: allow commenting questions and answers

closes #42

Author: drodil

plugins/qeta-backend/migrations/20230315-comments.js

@@ -0,0 +1,42 @@
+/**
+ * @param {import('knex').Knex} knex
+ */
+exports.up = async function up(knex) {
+  await knex.schema.createTable('question_comments', table => {
+    table.string('author').notNullable();
+    table.text('content').notNullable();
+    table.datetime('created').notNullable();
+    table.datetime('updated').nullable();
+    table.string('updatedBy').nullable();
+    table.integer('questionId').unsigned().notNullable();
+    table.increments('id');
+    table
+      .foreign('questionId')
+      .references('id')
+      .inTable('questions')
+      .onDelete('CASCADE');
+  });
+
+  await knex.schema.createTable('answer_comments', table => {
+    table.string('author').notNullable();
+    table.text('content').notNullable();
+    table.datetime('created').notNullable();
+    table.datetime('updated').nullable();
+    table.string('updatedBy').nullable();
+    table.integer('answerId').unsigned().notNullable();
+    table.increments('id');
+    table
+      .foreign('answerId')
+      .references('id')
+      .inTable('answers')
+      .onDelete('CASCADE');
+  });
+};
+
+/**
+ * @param {import('knex').Knex} knex
+ */
+exports.down = async function down(knex) {
+  await knex.schema.dropTable('question_comments');
+  await knex.schema.dropTable('answer_comments');
+};

plugins/qeta-backend/src/database/DatabaseQetaStore.test.ts

@@ -95,6 +95,8 @@ describe.each(databases.eachSupportedId())(
       await knex('answer_votes').del();
       await knex('question_views').del();
       await knex('tags').del();
+      await knex('question_comments').del();
+      await knex('answer_comments').del();
     });
 
     describe('questions and answers database', () => {
@@ -131,6 +133,13 @@ describe.each(databases.eachSupportedId())(
         expect(ans).toBeDefined();
         expect(ans?.content).toEqual('answer');
         expect(ans?.questionId).toEqual(id);
+
+        const ans2 = await storage.commentAnswer(
+          ans?.id ?? 0,
+          'user:default/user',
+          'this is comment',
+        );
+        expect(ans2?.comments?.length).toEqual(1);
       });
 
       it('should fetch list of questions', async () => {
@@ -266,6 +275,13 @@ describe.each(databases.eachSupportedId())(
         expect(ret2?.entities?.sort()).toEqual(
           ['component:default/comp2', 'component:default/comp3'].sort(),
         );
+
+        const ret3 = await storage.commentQuestion(
+          id1.id,
+          'user:default/user',
+          'this is comment',
+        );
+        expect(ret3?.comments?.length).toEqual(1);
       });
 
       it('should update question', async () => {

plugins/qeta-backend/src/database/DatabaseQetaStore.ts

@@ -67,6 +67,15 @@ export type RawTagEntity = {
   tag: string;
 };
 
+export type RawCommentEntity = {
+  id: number;
+  author: string;
+  content: string;
+  created: Date;
+  updated: Date;
+  updatedBy: string;
+};
+
 export class DatabaseQetaStore implements QetaStore {
   private constructor(private readonly db: Knex) {}
 
@@ -236,6 +245,7 @@ export class DatabaseQetaStore implements QetaStore {
       true,
       true,
       true,
+      true,
     );
   }
 
@@ -288,6 +298,65 @@ export class DatabaseQetaStore implements QetaStore {
     return this.mapQuestion(questions[0], false, false, true);
   }
 
+  async commentQuestion(
+    question_id: number,
+    user_ref: string,
+    content: string,
+  ): Promise<MaybeQuestion> {
+    await this.db
+      .insert({
+        author: user_ref,
+        content,
+        created: new Date(),
+        questionId: question_id,
+      })
+      .into('question_comments');
+
+    return await this.getQuestion(user_ref, question_id, false);
+  }
+
+  async deleteQuestionComment(
+    question_id: number,
+    id: number,
+    user_ref: string,
+  ): Promise<MaybeQuestion> {
+    await this.db('question_comments')
+      .where('id', '=', id)
+      .where('author', '=', user_ref)
+      .where('questionId', '=', question_id)
+      .delete();
+    return this.getQuestion(user_ref, question_id, false);
+  }
+
+  async commentAnswer(
+    answer_id: number,
+    user_ref: string,
+    content: string,
+  ): Promise<MaybeAnswer> {
+    await this.db
+      .insert({
+        author: user_ref,
+        content,
+        created: new Date(),
+        answerId: answer_id,
+      })
+      .into('answer_comments');
+    return this.getAnswer(answer_id);
+  }
+
+  async deleteAnswerComment(
+    answer_id: number,
+    id: number,
+    user_ref: string,
+  ): Promise<MaybeAnswer> {
+    await this.db('answer_comments')
+      .where('id', '=', id)
+      .where('author', '=', user_ref)
+      .where('answerId', '=', answer_id)
+      .delete();
+    return this.getAnswer(answer_id);
+  }
+
   async updateQuestion(
     id: number,
     user_ref: string,
@@ -358,7 +427,7 @@ export class DatabaseQetaStore implements QetaStore {
 
   async getAnswer(answerId: number): Promise<MaybeAnswer> {
     const answers = await this.getAnswerBaseQuery().where('id', '=', answerId);
-    return this.mapAnswer(answers[0], true);
+    return this.mapAnswer(answers[0], true, true);
   }
 
   async deleteAnswer(user_ref: string, id: number): Promise<boolean> {
@@ -489,13 +558,17 @@ export class DatabaseQetaStore implements QetaStore {
     addAnswers?: boolean,
     addVotes?: boolean,
     addEntities?: boolean,
+    addComments?: boolean,
   ): Promise<Question> {
     // TODO: This could maybe done with join
     const additionalInfo = await Promise.all([
       this.getQuestionTags(val.id),
-      addAnswers ? this.getQuestionAnswers(val.id, addVotes) : undefined,
+      addAnswers
+        ? this.getQuestionAnswers(val.id, addVotes, addComments)
+        : undefined,
       addVotes ? this.getQuestionVotes(val.id) : undefined,
       addEntities ? this.getQuestionEntities(val.id) : undefined,
+      addComments ? this.getQuestionComments(val.id) : undefined,
     ]);
     return {
       id: val.id,
@@ -515,14 +588,19 @@ export class DatabaseQetaStore implements QetaStore {
       votes: additionalInfo[2],
       entities: additionalInfo[3],
       trend: this.mapToInteger(val.trend),
+      comments: additionalInfo[4],
     };
   }
 
   private async mapAnswer(
     val: RawAnswerEntity,
     addVotes?: boolean,
+    addComments?: boolean,
   ): Promise<Answer> {
-    const votes = addVotes ? await this.getAnswerVotes(val.id) : undefined;
+    const additionalInfo = await Promise.all([
+      addVotes ? this.getAnswerVotes(val.id) : undefined,
+      addComments ? this.getAnswerComments(val.id) : undefined,
+    ]);
     return {
       id: val.id,
       questionId: val.questionId,
@@ -533,7 +611,8 @@ export class DatabaseQetaStore implements QetaStore {
       updated: val.updated,
       updatedBy: val.updatedBy,
       score: this.mapToInteger(val.score),
-      votes,
+      votes: additionalInfo[0],
+      comments: additionalInfo[1],
     };
   }
 
@@ -553,6 +632,22 @@ export class DatabaseQetaStore implements QetaStore {
     return rows.map(val => val.tag);
   }
 
+  private async getQuestionComments(
+    questionId: number,
+  ): Promise<RawCommentEntity[]> {
+    return this.db<RawCommentEntity>('question_comments') // nosonar
+      .where('question_comments.questionId', '=', questionId)
+      .select();
+  }
+
+  private async getAnswerComments(
+    answerId: number,
+  ): Promise<RawCommentEntity[]> {
+    return this.db<RawCommentEntity>('answer_comments') // nosonar
+      .where('answer_comments.answerId', '=', answerId)
+      .select();
+  }
+
   private async getQuestionEntities(questionId: number): Promise<string[]> {
     const rows = await this.db<RawTagEntity>('entities') // nosonar
       .leftJoin(
@@ -596,14 +691,15 @@ export class DatabaseQetaStore implements QetaStore {
   private async getQuestionAnswers(
     questionId: number,
     addVotes?: boolean,
+    addComments?: boolean,
   ): Promise<Answer[]> {
     const rows = await this.getAnswerBaseQuery()
       .where('questionId', '=', questionId)
       .orderBy('answers.correct', 'desc')
       .orderBy('answers.created');
     return await Promise.all(
       rows.map(async val => {
-        return this.mapAnswer(val, addVotes);
+        return this.mapAnswer(val, addVotes, addComments);
       }),
     );
   }

plugins/qeta-backend/src/database/QetaStore.ts

@@ -18,6 +18,7 @@ export interface Question {
   own?: boolean;
   votes?: Vote[];
   trend?: number;
+  comments?: Comment[];
 }
 
 export interface Answer {
@@ -33,6 +34,7 @@ export interface Answer {
   ownVote?: number;
   own?: boolean;
   votes?: Vote[];
+  comments?: Comment[];
 }
 
 export interface Vote {
@@ -41,6 +43,15 @@ export interface Vote {
   timestamp: Date;
 }
 
+export interface Comment {
+  author: string;
+  content: string;
+  created: Date;
+  own?: boolean;
+  updated?: Date;
+  updatedBy?: string;
+}
+
 export type MaybeAnswer = Answer | null;
 export type MaybeQuestion = Question | null;
 
@@ -133,6 +144,30 @@ export interface QetaStore {
     components?: string[],
   ): Promise<Question>;
 
+  /**
+   * Comment question
+   * @param question_id question id
+   * @param user_ref user
+   * @param content comment content
+   */
+  commentQuestion(
+    question_id: number,
+    user_ref: string,
+    content: string,
+  ): Promise<MaybeQuestion>;
+
+  /**
+   * Delete question comment
+   * @param question_id question id
+   * @param id comment id
+   * @param user_ref username
+   */
+  deleteQuestionComment(
+    question_id: number,
+    id: number,
+    user_ref: string,
+  ): Promise<MaybeQuestion>;
+
   /**
    * Update question
    * @param id question id
@@ -170,6 +205,30 @@ export interface QetaStore {
     answer: string,
   ): Promise<MaybeAnswer>;
 
+  /**
+   * Comment answer
+   * @param answer_id answer id
+   * @param user_ref user commenting
+   * @param content comment content
+   */
+  commentAnswer(
+    answer_id: number,
+    user_ref: string,
+    content: string,
+  ): Promise<MaybeAnswer>;
+
+  /**
+   * Delete answer comment
+   * @param answer_id answer id
+   * @param id comment id
+   * @param user_ref username
+   */
+  deleteAnswerComment(
+    answer_id: number,
+    id: number,
+    user_ref: string,
+  ): Promise<MaybeAnswer>;
+
   /**
    * Update answer to a question
    * @param user_ref user name of the user updating the answer

plugins/qeta-backend/src/service/router.test.ts

@@ -57,6 +57,10 @@ describe('createRouter', () => {
   let app: express.Express;
 
   const qetaStore: jest.Mocked<QetaStore> = {
+    commentAnswer: jest.fn(),
+    commentQuestion: jest.fn(),
+    deleteAnswerComment: jest.fn(),
+    deleteQuestionComment: jest.fn(),
     getQuestions: jest.fn(),
     getQuestion: jest.fn(),
     getQuestionByAnswerId: jest.fn(),