Transfer /viewComments + comment spam routes to new framework

libs/model/src/comment/GetComments.query.ts

@@ -1,7 +1,7 @@
 import { type Query } from '@hicommonwealth/core';
 import * as schemas from '@hicommonwealth/schemas';
 import { models } from '../database';
-import { removeUndefined } from '../utils/index';
+import { removeUndefined, sanitizeDeletedComment } from '../utils/index';
 import { formatSequelizePagination } from '../utils/paginationUtils';
 
 export function GetComments(): Query<typeof schemas.GetComments> {
@@ -58,7 +58,15 @@ export function GetComments(): Query<typeof schemas.GetComments> {
         paranoid: false,
       });
 
-      return schemas.buildPaginatedResponse(comments, count as number, payload);
+      const sanitizedComments = comments.map((c) => {
+        const data = c.toJSON();
+        return {
+          ...sanitizeDeletedComment(data),
+          last_edited: data.updated_at,
+        };
+      });
+
+      return schemas.buildPaginatedResponse(sanitizedComments, count, payload);
     },
   };
 }

libs/model/src/comment/SetCommentSpam.command.ts

@@ -0,0 +1,37 @@
+import { InvalidState, type Command } from '@hicommonwealth/core';
+import * as schemas from '@hicommonwealth/schemas';
+import { models } from '../database';
+import { isAuthorized, type AuthContext } from '../middleware';
+
+export const MarkCommentAsSpamErrors = {
+  CommentNotFound: 'Could not find Comment',
+};
+
+export function SetCommentSpam(): Command<
+  typeof schemas.SetCommentSpam,
+  AuthContext
+> {
+  return {
+    ...schemas.SetCommentSpam,
+    auth: [isAuthorized({ roles: ['admin', 'moderator'] })],
+    body: async ({ payload }) => {
+      const comment = await models.Comment.findOne({
+        where: { id: payload.comment_id },
+        include: [{ model: models.Thread, attributes: ['community_id'] }],
+      });
+      if (!comment) {
+        throw new InvalidState(MarkCommentAsSpamErrors.CommentNotFound);
+      }
+
+      if (payload.spam && !comment.marked_as_spam_at) {
+        comment.marked_as_spam_at = new Date();
+        await comment.save();
+      } else if (!payload.spam && comment.marked_as_spam_at) {
+        comment.marked_as_spam_at = null;
+        await comment.save();
+      }
+
+      return comment;
+    },
+  };
+}

libs/model/src/comment/ViewComments.query.ts

@@ -0,0 +1,74 @@
+import { type Query } from '@hicommonwealth/core';
+import * as schemas from '@hicommonwealth/schemas';
+import { models } from '../database';
+import { sanitizeDeletedComment } from '../utils/sanitizeDeletedComment';
+
+export function ViewComments(): Query<typeof schemas.ViewComments> {
+  return {
+    ...schemas.ViewComments,
+    auth: [],
+    body: async ({ payload }) => {
+      const comments = await models.Comment.findAll({
+        include: [
+          {
+            model: models.Address,
+            required: true,
+            include: [
+              {
+                model: models.User,
+                as: 'User',
+                required: true,
+                attributes: ['id', 'profile'],
+              },
+            ],
+          },
+          {
+            model: models.Thread,
+            attributes: ['id'],
+            required: true,
+            where: { id: payload.thread_id },
+          },
+          {
+            model: models.Reaction,
+            as: 'reactions',
+            include: [
+              {
+                model: models.Address,
+                as: 'Address',
+                required: true,
+                attributes: ['address', 'last_active'],
+                include: [
+                  {
+                    model: models.User,
+                    as: 'User',
+                    required: true,
+                    attributes: ['id', 'profile'],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            model: models.CommentVersionHistory,
+          },
+        ],
+        order: [['created_at', 'DESC']],
+        paranoid: false,
+      });
+
+      return comments.map((c) => {
+        const data = c.toJSON();
+        return {
+          ...sanitizeDeletedComment(data),
+          last_edited: data.updated_at?.toISOString(),
+          community_id: data.Thread!.community_id!,
+          Address: {
+            ...data.Address!,
+            User: data.Address!.User!,
+          },
+          Thread: data.Thread!,
+        };
+      });
+    },
+  };
+}

libs/model/src/comment/index.ts

@@ -3,4 +3,6 @@ export * from './CreateCommentReaction.command';
 export * from './DeleteComment.command';
 export * from './GetComments.query';
 export * from './SearchComments.query';
+export * from './SetCommentSpam.command';
 export * from './UpdateComment.command';
+export * from './ViewComments.query';

libs/model/src/utils/index.ts

@@ -3,6 +3,7 @@ export * from './denormalizedCountUtils';
 export * from './getDelta';
 export * from './makeGetBalancesOptions';
 export * from './parseUserMentions';
+export * from './sanitizeDeletedComment';
 export * from './sanitizeQuillText';
 export * from './updateTags';
 export * from './utils';

packages/commonwealth/server/util/sanitizeDeletedComment.ts → libs/model/src/utils/sanitizeDeletedComment.ts

@@ -1,4 +1,4 @@
-import { CommentAttributes } from '@hicommonwealth/model';
+import { CommentAttributes } from '../models/comment';
 
 export function sanitizeDeletedComment(
   comment: CommentAttributes,

libs/schemas/src/commands/comment.schemas.ts

@@ -50,3 +50,11 @@ export const DeleteComment = {
     canvas_msg_id: z.string().nullish(),
   }),
 };
+
+export const SetCommentSpam = {
+  input: z.object({
+    comment_id: PG_INT,
+    spam: z.boolean(),
+  }),
+  output: Comment,
+};

libs/schemas/src/queries/comment.schemas.ts

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { Comment } from '../entities';
+import { Address, Comment, Thread, User } from '../entities';
 import { PG_INT, zBoolean } from '../utils';
 import { PaginatedResultSchema, PaginationParamsSchema } from './pagination';
 
@@ -25,6 +25,23 @@ export const GetComments = {
     include_reactions: zBoolean.default(false),
   }),
   output: PaginatedResultSchema.extend({
-    results: Comment.array(),
+    results: Comment.extend({
+      last_edited: z.coerce.date().optional(),
+    }).array(),
   }),
 };
+
+// Similar to GetComments but used exclusively in our client (LEGACY)
+export const ViewComments = {
+  input: z.object({
+    thread_id: PG_INT,
+  }),
+  output: Comment.extend({
+    last_edited: z.string().nullish(),
+    community_id: z.string(),
+    Address: Address.extend({
+      User: User,
+    }),
+    Thread: Thread,
+  }).array(),
+};

packages/commonwealth/client/scripts/state/api/comments/fetchComments.ts

@@ -1,45 +1,57 @@
-import { useQuery } from '@tanstack/react-query';
-import axios from 'axios';
+import { ViewComments } from '@hicommonwealth/schemas';
 import Comment from 'models/Comment';
-import app from 'state';
-import { ApiEndpoints, SERVER_URL } from 'state/api/config';
+import { trpc } from 'utils/trpcClient';
+import { z } from 'zod';
 
 const COMMENTS_STALE_TIME = 30 * 1_000; // 30 s
 
-interface FetchCommentsProps {
-  threadId: number;
-  communityId: string;
-  apiEnabled?: boolean;
-}
-
-const fetchComments = async ({ communityId, threadId }: FetchCommentsProps) => {
-  const response = await axios.get(
-    `${SERVER_URL}${ApiEndpoints.FETCH_COMMENTS}`,
-    {
-      params: {
-        community_id: communityId || app.activeChainId(),
-        thread_id: threadId,
-      },
-    },
+/**
+ * @Deprecated
+ */
+const mapToLegacyCommentsModel = async (
+  comments: z.infer<typeof ViewComments.output>,
+) => {
+  return comments.map(
+    (c) =>
+      new Comment({
+        id: c.id,
+        text: c.text,
+        author: c.Address.address,
+        community_id: c.community_id,
+        Address: c.Address,
+        thread_id: c.thread_id,
+        parent_id: c.parent_id,
+        // TODO: why is this not plural
+        reactions: c.Reaction,
+        reaction_weights_sum: c.reaction_weights_sum,
+        created_at: c.created_at,
+        deleted_at: c.deleted_at,
+        authorChain: c.Thread.community_id,
+        last_edited: c.last_edited,
+        canvas_signed_data: c.canvas_signed_data,
+        canvas_msg_id: c.canvas_msg_id,
+        CommentVersionHistories: c.CommentVersionHistories,
+        marked_as_spam_at: c.marked_as_spam_at,
+        discord_meta: c.discord_meta,
+      }),
   );
+};
 
-  // transform response
-  return response.data.result.map(
-    (c) => new Comment({ community_id: undefined, ...c }),
-  );
+type useViewCommentsProps = z.infer<typeof ViewComments.input> & {
+  apiEnabled?: boolean;
 };
 
 const useFetchCommentsQuery = ({
-  communityId,
-  threadId,
+  thread_id,
   apiEnabled = true,
-}: FetchCommentsProps) => {
-  return useQuery({
-    queryKey: [ApiEndpoints.FETCH_COMMENTS, communityId, threadId],
-    queryFn: () => fetchComments({ communityId, threadId }),
-    staleTime: COMMENTS_STALE_TIME,
-    enabled: apiEnabled,
-  });
+}: useViewCommentsProps) => {
+  return trpc.comment.viewComments.useQuery(
+    { thread_id },
+    {
+      enabled: apiEnabled,
+      staleTime: COMMENTS_STALE_TIME,
+    },
+  );
 };
 
 export default useFetchCommentsQuery;

packages/commonwealth/server/api/comment.ts

@@ -31,4 +31,6 @@ export const trpcRouter = trpc.router({
   searchComments: trpc.query(Comment.SearchComments, trpc.Tag.Comment),
   getComments: trpc.query(Comment.GetComments, trpc.Tag.Comment),
   deleteComment: trpc.command(Comment.DeleteComment, trpc.Tag.Comment),
+  setCommentSpam: trpc.command(Comment.SetCommentSpam, trpc.Tag.Comment),
+  viewComments: trpc.query(Comment.ViewComments, trpc.Tag.Comment),
 });

packages/commonwealth/server/api/external-router.ts

@@ -32,8 +32,13 @@ const {
   deleteReaction,
   deleteThread,
 } = thread.trpcRouter;
-const { createComment, updateComment, deleteComment, createCommentReaction } =
-  comment.trpcRouter;
+const {
+  createComment,
+  updateComment,
+  deleteComment,
+  createCommentReaction,
+  setCommentSpam,
+} = comment.trpcRouter;
 const { getNewContent } = user.trpcRouter;
 
 const api = {
@@ -82,6 +87,7 @@ const api = {
   deleteReaction,
   joinCommunity,
   banAddress,
+  setCommentSpam,
 };
 
 const PATH = '/api/v1';

packages/commonwealth/server/routes/viewComments.ts

@@ -1,7 +1,7 @@
 import { AppError } from '@hicommonwealth/core';
 import type { DB } from '@hicommonwealth/model';
+import { sanitizeDeletedComment } from '@hicommonwealth/model';
 import type { NextFunction, Request, Response } from 'express';
-import { sanitizeDeletedComment } from 'server/util/sanitizeDeletedComment';
 
 export const Errors = {
   NoRootId: 'Must provide thread_id',