feat: resolve comment (EE)

apps/client/public/locales/en-US/translation.json

@@ -213,7 +213,18 @@
   "Comment deleted successfully": "Comment deleted successfully",
   "Failed to delete comment": "Failed to delete comment",
   "Comment resolved successfully": "Comment resolved successfully",
+  "Comment re-opened successfully": "Comment re-opened successfully",
+  "Comment unresolved successfully": "Comment unresolved successfully",
   "Failed to resolve comment": "Failed to resolve comment",
+  "Resolve comment": "Resolve comment",
+  "Unresolve comment": "Unresolve comment",
+  "Resolve Comment Thread": "Resolve Comment Thread",
+  "Unresolve Comment Thread": "Unresolve Comment Thread",
+  "Are you sure you want to resolve this comment thread? This will mark it as completed.": "Are you sure you want to resolve this comment thread? This will mark it as completed.",
+  "Are you sure you want to unresolve this comment thread?": "Are you sure you want to unresolve this comment thread?",
+  "Resolved": "Resolved",
+  "No active comments.": "No active comments.",
+  "No resolved comments.": "No resolved comments.",
   "Revoke invitation": "Revoke invitation",
   "Revoke": "Revoke",
   "Don't": "Don't",
@@ -356,7 +367,7 @@
   "{{latestVersion}} is available": "{{latestVersion}} is available",
   "Default page edit mode": "Default page edit mode",
   "Choose your preferred page edit mode. Avoid accidental edits.": "Choose your preferred page edit mode. Avoid accidental edits.",
-  "Reading": "Reading"
+  "Reading": "Reading",
   "Delete member": "Delete member",
   "Member deleted successfully": "Member deleted successfully",
   "Are you sure you want to delete this workspace member? This action is irreversible.": "Are you sure you want to delete this workspace member? This action is irreversible.",

apps/client/src/components/layouts/global/aside.tsx

@@ -1,5 +1,5 @@
 import { Box, ScrollArea, Text } from "@mantine/core";
-import CommentList from "@/features/comment/components/comment-list.tsx";
+import CommentListWithTabs from "@/features/comment/components/comment-list-with-tabs.tsx";
 import { useAtom } from "jotai";
 import { asideStateAtom } from "@/components/layouts/global/hooks/atoms/sidebar-atom.ts";
 import React, { ReactNode } from "react";
@@ -18,7 +18,7 @@ export default function Aside() {
 
   switch (tab) {
     case "comments":
-      component = <CommentList />;
+      component = <CommentListWithTabs />;
       title = "Comments";
       break;
     case "toc":

apps/client/src/ee/comment/components/resolve-comment.tsx

@@ -0,0 +1,54 @@
+import { ActionIcon, Tooltip } from "@mantine/core";
+import { IconCircleCheck, IconCircleCheckFilled } from "@tabler/icons-react";
+import { useResolveCommentMutation } from "@/ee/comment/queries/comment-query";
+import { useTranslation } from "react-i18next";
+
+interface ResolveCommentProps {
+  commentId: string;
+  pageId: string;
+  resolvedAt?: Date;
+}
+
+function ResolveComment({ commentId, pageId, resolvedAt }: ResolveCommentProps) {
+  const { t } = useTranslation();
+  const resolveCommentMutation = useResolveCommentMutation();
+
+  const isResolved = resolvedAt != null;
+  const iconColor = isResolved ? "green" : "gray";
+
+  const handleResolveToggle = async () => {
+    try {
+      await resolveCommentMutation.mutateAsync({
+        commentId,
+        pageId,
+        resolved: !isResolved,
+      });
+    } catch (error) {
+      console.error("Failed to toggle resolved state:", error);
+    }
+  };
+
+  return (
+    <Tooltip 
+      label={isResolved ? t("Re-Open comment") : t("Resolve comment")}
+      position="top"
+    >
+      <ActionIcon
+        onClick={handleResolveToggle}
+        variant="subtle"
+        color={isResolved ? "green" : "gray"}
+        size="sm"
+        loading={resolveCommentMutation.isPending}
+        disabled={resolveCommentMutation.isPending}
+      >
+        {isResolved ? (
+          <IconCircleCheckFilled size={18} />
+        ) : (
+          <IconCircleCheck size={18} />
+        )}
+      </ActionIcon>
+    </Tooltip>
+  );
+}
+
+export default ResolveComment; 

apps/client/src/ee/comment/queries/comment-query.ts

@@ -0,0 +1,87 @@
+import {
+  useMutation,
+  useQueryClient,
+} from "@tanstack/react-query";
+import { resolveComment } from "@/features/comment/services/comment-service";
+import {
+  IComment,
+  IResolveComment,
+} from "@/features/comment/types/comment.types";
+import { notifications } from "@mantine/notifications";
+import { IPagination } from "@/lib/types.ts";
+import { useTranslation } from "react-i18next";
+import { useQueryEmit } from "@/features/websocket/use-query-emit";
+import { RQ_KEY } from "@/features/comment/queries/comment-query";
+
+export function useResolveCommentMutation() {
+  const queryClient = useQueryClient();
+  const { t } = useTranslation();
+  const emit = useQueryEmit();
+
+  return useMutation({
+    mutationFn: (data: IResolveComment) => resolveComment(data),
+    onMutate: async (variables) => {
+      await queryClient.cancelQueries({ queryKey: RQ_KEY(variables.pageId) });
+      const previousComments = queryClient.getQueryData(RQ_KEY(variables.pageId));
+      queryClient.setQueryData(RQ_KEY(variables.pageId), (old: IPagination<IComment>) => {
+        if (!old || !old.items) return old;
+        const updatedItems = old.items.map((comment) =>
+          comment.id === variables.commentId
+            ? { 
+                ...comment, 
+                resolvedAt: variables.resolved ? new Date() : null, 
+                resolvedById: variables.resolved ? 'optimistic-user' : null,
+                resolvedBy: variables.resolved ? { id: 'optimistic-user', name: 'Resolving...', avatarUrl: null } : null
+              }
+            : comment,
+        );
+        return {
+          ...old,
+          items: updatedItems,
+        };
+      });
+      return { previousComments };
+    },
+    onError: (err, variables, context) => {
+      if (context?.previousComments) {
+        queryClient.setQueryData(RQ_KEY(variables.pageId), context.previousComments);
+      }
+      notifications.show({
+        message: t("Failed to resolve comment"),
+        color: "red",
+      });
+    },
+    onSuccess: (data: IComment, variables) => {
+      const pageId = data.pageId;
+      const currentComments = queryClient.getQueryData(
+        RQ_KEY(pageId),
+      ) as IPagination<IComment>;
+      if (currentComments && currentComments.items) {
+        const updatedComments = currentComments.items.map((comment) =>
+          comment.id === variables.commentId
+            ? { ...comment, resolvedAt: data.resolvedAt, resolvedById: data.resolvedById, resolvedBy: data.resolvedBy }
+            : comment,
+        );
+        queryClient.setQueryData(RQ_KEY(pageId), {
+          ...currentComments,
+          items: updatedComments,
+        });
+      }
+      emit({
+        operation: "resolveComment",
+        pageId: pageId,
+        commentId: variables.commentId,
+        resolved: variables.resolved,
+        resolvedAt: data.resolvedAt,
+        resolvedById: data.resolvedById,
+        resolvedBy: data.resolvedBy,
+      });
+      queryClient.invalidateQueries({ queryKey: RQ_KEY(pageId) });
+      notifications.show({ 
+        message: variables.resolved 
+          ? t("Comment resolved successfully") 
+          : t("Comment re-opened successfully") 
+      });
+    },
+  });
+} 

apps/client/src/features/comment/components/comment-list-item.tsx

@@ -1,4 +1,4 @@
-import { Group, Text, Box } from "@mantine/core";
+import { Group, Text, Box, Badge } from "@mantine/core";
 import React, { useEffect, useState } from "react";
 import classes from "./comment.module.css";
 import { useAtom, useAtomValue } from "jotai";
@@ -7,6 +7,8 @@ import CommentEditor from "@/features/comment/components/comment-editor";
 import { pageEditorAtom } from "@/features/editor/atoms/editor-atoms";
 import CommentActions from "@/features/comment/components/comment-actions";
 import CommentMenu from "@/features/comment/components/comment-menu";
+import { useIsCloudEE } from "@/hooks/use-is-cloud-ee";
+import ResolveComment from "@/ee/comment/components/resolve-comment";
 import { useHover } from "@mantine/hooks";
 import {
   useDeleteCommentMutation,
@@ -16,6 +18,7 @@ import { IComment } from "@/features/comment/types/comment.types";
 import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom.ts";
 import { useQueryEmit } from "@/features/websocket/use-query-emit";
+import { useTranslation } from "react-i18next";
 
 interface CommentListItemProps {
   comment: IComment;
@@ -23,6 +26,7 @@ interface CommentListItemProps {
 }
 
 function CommentListItem({ comment, pageId }: CommentListItemProps) {
+  const { t } = useTranslation();
   const { hovered, ref } = useHover();
   const [isEditing, setIsEditing] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
@@ -32,6 +36,7 @@ function CommentListItem({ comment, pageId }: CommentListItemProps) {
   const deleteCommentMutation = useDeleteCommentMutation(comment.pageId);
   const [currentUser] = useAtom(currentUserAtom);
   const emit = useQueryEmit();
+  const isCloudEE = useIsCloudEE();
 
   useEffect(() => {
     setContent(comment.content)
@@ -106,9 +111,13 @@ function CommentListItem({ comment, pageId }: CommentListItemProps) {
             </Text>
 
             <div style={{ visibility: hovered ? "visible" : "hidden" }}>
-              {/*!comment.parentCommentId && (
-                <ResolveComment commentId={comment.id} pageId={comment.pageId} resolvedAt={comment.resolvedAt} />
-              )*/}
+              {!comment.parentCommentId && isCloudEE && (
+                <ResolveComment 
+                  commentId={comment.id} 
+                  pageId={comment.pageId} 
+                  resolvedAt={comment.resolvedAt} 
+                />
+              )}
 
               {currentUser?.user?.id === comment.creatorId && (
                 <CommentMenu
@@ -119,9 +128,11 @@ function CommentListItem({ comment, pageId }: CommentListItemProps) {
             </div>
           </Group>
 
-          <Text size="xs" fw={500} c="dimmed">
-            {timeAgo(comment.createdAt)}
-          </Text>
+          <Group gap="xs">
+            <Text size="xs" fw={500} c="dimmed">
+              {timeAgo(comment.createdAt)}
+            </Text>
+          </Group>
         </div>
       </Group>
 

apps/client/src/features/comment/components/comment-list-with-tabs.tsx

@@ -0,0 +1,239 @@
+import React, { useState, useRef, useCallback, memo, useMemo } from "react";
+import { useParams } from "react-router-dom";
+import { Divider, Paper, Tabs, Badge, Text } from "@mantine/core";
+import CommentListItem from "@/features/comment/components/comment-list-item";
+import {
+  useCommentsQuery,
+  useCreateCommentMutation,
+} from "@/features/comment/queries/comment-query";
+import CommentEditor from "@/features/comment/components/comment-editor";
+import CommentActions from "@/features/comment/components/comment-actions";
+import { useFocusWithin } from "@mantine/hooks";
+import { IComment } from "@/features/comment/types/comment.types.ts";
+import { usePageQuery } from "@/features/page/queries/page-query.ts";
+import { IPagination } from "@/lib/types.ts";
+import { extractPageSlugId } from "@/lib";
+import { useTranslation } from "react-i18next";
+import { useQueryEmit } from "@/features/websocket/use-query-emit";
+import { useIsCloudEE } from "@/hooks/use-is-cloud-ee";
+
+function CommentListWithTabs() {
+  const { t } = useTranslation();
+  const { pageSlug } = useParams();
+  const { data: page } = usePageQuery({ pageId: extractPageSlugId(pageSlug) });
+  const {
+    data: comments,
+    isLoading: isCommentsLoading,
+    isError,
+  } = useCommentsQuery({ pageId: page?.id, limit: 100 });
+  const createCommentMutation = useCreateCommentMutation();
+  const [isLoading, setIsLoading] = useState(false);
+  const emit = useQueryEmit();
+  const isCloudEE = useIsCloudEE();
+
+  // Separate active and resolved comments
+  const { activeComments, resolvedComments } = useMemo(() => {
+    if (!comments?.items) {
+      return { activeComments: [], resolvedComments: [] };
+    }
+
+    const parentComments = comments.items.filter(
+      (comment: IComment) => comment.parentCommentId === null
+    );
+
+    const active = parentComments.filter(
+      (comment: IComment) => !comment.resolvedAt
+    );
+    const resolved = parentComments.filter(
+      (comment: IComment) => comment.resolvedAt
+    );
+
+    return { activeComments: active, resolvedComments: resolved };
+  }, [comments]);
+
+  const handleAddReply = useCallback(
+    async (commentId: string, content: string) => {
+      try {
+        setIsLoading(true);
+        const commentData = {
+          pageId: page?.id,
+          parentCommentId: commentId,
+          content: JSON.stringify(content),
+        };
+
+        await createCommentMutation.mutateAsync(commentData);
+
+        emit({
+          operation: "invalidateComment",
+          pageId: page?.id,
+        });
+      } catch (error) {
+        console.error("Failed to post comment:", error);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [createCommentMutation, page?.id],
+  );
+
+  const renderComments = useCallback(
+    (comment: IComment) => (
+      <Paper
+        shadow="sm"
+        radius="md"
+        p="sm"
+        mb="sm"
+        withBorder
+        key={comment.id}
+        data-comment-id={comment.id}
+      >
+        <div>
+          <CommentListItem comment={comment} pageId={page?.id} />
+          <MemoizedChildComments comments={comments} parentId={comment.id} pageId={page?.id} />
+        </div>
+
+        {!comment.resolvedAt && (
+          <>
+            <Divider my={4} />
+            <CommentEditorWithActions
+              commentId={comment.id}
+              onSave={handleAddReply}
+              isLoading={isLoading}
+            />
+          </>
+        )}
+      </Paper>
+    ),
+    [comments, handleAddReply, isLoading],
+  );
+
+  if (isCommentsLoading) {
+    return <></>;
+  }
+
+  if (isError) {
+    return <div>{t("Error loading comments.")}</div>;
+  }
+
+  const totalComments = (activeComments.length + resolvedComments.length);
+
+  if (totalComments === 0) {
+    return <>{t("No comments yet.")}</>;
+  }
+
+  // If not cloud/enterprise, show simple list without tabs
+  if (!isCloudEE) {
+    return (
+      <div>
+        {comments?.items
+          .filter((comment: IComment) => comment.parentCommentId === null)
+          .map(renderComments)}
+      </div>
+    );
+  }
+
+  return (
+    <Tabs defaultValue="open" variant="default">
+      <Tabs.List justify="center">
+        <Tabs.Tab 
+          value="open" 
+          leftSection={
+            <Badge size="xs" variant="light" color="blue">
+              {activeComments.length}
+            </Badge>
+          }
+        >
+          {t("Open")}
+        </Tabs.Tab>
+        <Tabs.Tab 
+          value="resolved" 
+          leftSection={
+            <Badge size="xs" variant="light" color="green">
+              {resolvedComments.length}
+            </Badge>
+          }
+        >
+          {t("Resolved")}
+        </Tabs.Tab>
+      </Tabs.List>
+
+      <Tabs.Panel value="open" pt="xs">
+        {activeComments.length === 0 ? (
+          <Text size="sm" c="dimmed" ta="center" py="md">
+            {t("No open comments.")}
+          </Text>
+        ) : (
+          activeComments.map(renderComments)
+        )}
+      </Tabs.Panel>
+
+      <Tabs.Panel value="resolved" pt="xs">
+        {resolvedComments.length === 0 ? (
+          <Text size="sm" c="dimmed" ta="center" py="md">
+            {t("No resolved comments.")}
+          </Text>
+        ) : (
+          resolvedComments.map(renderComments)
+        )}
+      </Tabs.Panel>
+    </Tabs>
+  );
+}
+
+interface ChildCommentsProps {
+  comments: IPagination<IComment>;
+  parentId: string;
+  pageId: string;
+}
+const ChildComments = ({ comments, parentId, pageId }: ChildCommentsProps) => {
+  const getChildComments = useCallback(
+    (parentId: string) =>
+      comments.items.filter(
+        (comment: IComment) => comment.parentCommentId === parentId,
+      ),
+    [comments.items],
+  );
+
+  return (
+    <div>
+      {getChildComments(parentId).map((childComment) => (
+        <div key={childComment.id}>
+          <CommentListItem comment={childComment} pageId={pageId} />
+          <MemoizedChildComments
+            comments={comments}
+            parentId={childComment.id}
+            pageId={pageId}
+          />
+        </div>
+      ))}
+    </div>
+  );
+};
+
+const MemoizedChildComments = memo(ChildComments);
+
+const CommentEditorWithActions = ({ commentId, onSave, isLoading }) => {
+  const [content, setContent] = useState("");
+  const { ref, focused } = useFocusWithin();
+  const commentEditorRef = useRef(null);
+
+  const handleSave = useCallback(() => {
+    onSave(commentId, content);
+    setContent("");
+    commentEditorRef.current?.clearContent();
+  }, [commentId, content, onSave]);
+
+  return (
+    <div ref={ref}>
+      <CommentEditor
+        ref={commentEditorRef}
+        onUpdate={setContent}
+        onSave={handleSave}
+        editable={true}
+      />
+      {focused && <CommentActions onSave={handleSave} isLoading={isLoading} />}
+    </div>
+  );
+};
+
+export default CommentListWithTabs; 

apps/client/src/features/comment/components/resolve-comment.tsx

@@ -1,47 +0,0 @@
-import { ActionIcon } from "@mantine/core";
-import { IconCircleCheck } from "@tabler/icons-react";
-import { modals } from "@mantine/modals";
-import { useResolveCommentMutation } from "@/features/comment/queries/comment-query";
-import { useTranslation } from "react-i18next";
-
-function ResolveComment({ commentId, pageId, resolvedAt }) {
-  const { t } = useTranslation();
-  const resolveCommentMutation = useResolveCommentMutation();
-
-  const isResolved = resolvedAt != null;
-  const iconColor = isResolved ? "green" : "gray";
-
-  //@ts-ignore
-  const openConfirmModal = () =>
-    modals.openConfirmModal({
-      title: t("Are you sure you want to resolve this comment thread?"),
-      centered: true,
-      labels: { confirm: t("Confirm"), cancel: t("Cancel") },
-      onConfirm: handleResolveToggle,
-    });
-
-  const handleResolveToggle = async () => {
-    try {
-      await resolveCommentMutation.mutateAsync({
-        commentId,
-        resolved: !isResolved,
-      });
-      //TODO: remove comment mark
-      // Remove comment thread from state on resolve
-    } catch (error) {
-      console.error("Failed to toggle resolved state:", error);
-    }
-  };
-
-  return (
-    <ActionIcon
-      onClick={openConfirmModal}
-      variant="default"
-      style={{ border: "none" }}
-    >
-      <IconCircleCheck size={20} stroke={2} color={iconColor} />
-    </ActionIcon>
-  );
-}
-
-export default ResolveComment;

apps/client/src/features/comment/queries/comment-query.ts

@@ -8,13 +8,11 @@ import {
   createComment,
   deleteComment,
   getPageComments,
-  resolveComment,
   updateComment,
 } from "@/features/comment/services/comment-service";
 import {
   ICommentParams,
   IComment,
-  IResolveComment,
 } from "@/features/comment/types/comment.types";
 import { notifications } from "@mantine/notifications";
 import { IPagination } from "@/lib/types.ts";
@@ -108,34 +106,4 @@ export function useDeleteCommentMutation(pageId?: string) {
   });
 }
 
-export function useResolveCommentMutation() {
-  const queryClient = useQueryClient();
-  const { t } = useTranslation();
-
-  return useMutation({
-    mutationFn: (data: IResolveComment) => resolveComment(data),
-    onSuccess: (data: IComment, variables) => {
-      const currentComments = queryClient.getQueryData(
-        RQ_KEY(data.pageId),
-      ) as IComment[];
-
-      /*
-      if (currentComments) {
-        const updatedComments = currentComments.map((comment) =>
-          comment.id === variables.commentId
-            ? { ...comment, ...data }
-            : comment,
-        );
-        queryClient.setQueryData(RQ_KEY(data.pageId), updatedComments);
-      }*/
-
-      notifications.show({ message: t("Comment resolved successfully") });
-    },
-    onError: (error) => {
-      notifications.show({
-        message: t("Failed to resolve comment"),
-        color: "red",
-      });
-    },
-  });
-}
+// EE: useResolveCommentMutation has been moved to @/ee/comment/queries/comment-query

apps/client/src/features/comment/types/comment.types.ts

@@ -16,6 +16,7 @@ export interface IComment {
   editedAt?: Date;
   deletedAt?: Date;
   creator: IUser;
+  resolvedBy?: IUser;
 }
 
 export interface ICommentData {
@@ -28,6 +29,7 @@ export interface ICommentData {
 
 export interface IResolveComment {
   commentId: string;
+  pageId: string;
   resolved: boolean;
 }
 

apps/client/src/features/websocket/types/types.ts

@@ -63,6 +63,20 @@ export type RefetchRootTreeNodeEvent = {
   spaceId: string;
 };
 
+export type ResolveCommentEvent = {
+  operation: "resolveComment";
+  pageId: string;
+  commentId: string;
+  resolved: boolean;
+  resolvedAt?: Date;
+  resolvedById?: string;
+  resolvedBy?: {
+    id: string;
+    name: string;
+    avatarUrl?: string | null;
+  };
+};
+
 export type WebSocketEvent =
   | InvalidateEvent
   | InvalidateCommentsEvent
@@ -71,4 +85,5 @@ export type WebSocketEvent =
   | AddTreeNodeEvent
   | MoveTreeNodeEvent
   | DeleteTreeNodeEvent
-  | RefetchRootTreeNodeEvent;
+  | RefetchRootTreeNodeEvent
+  | ResolveCommentEvent;

apps/client/src/features/websocket/use-query-subscription.ts

@@ -13,6 +13,7 @@ import {
 } from "../page/queries/page-query";
 import { RQ_KEY } from "../comment/queries/comment-query";
 import { queryClient } from "@/main.tsx";
+import { IComment } from "@/features/comment/types/comment.types";
 
 export const useQuerySubscription = () => {
   const queryClient = useQueryClient();
@@ -96,6 +97,30 @@ export const useQuerySubscription = () => {
           });
           break;
         }
+        case "resolveComment": {
+          const currentComments = queryClient.getQueryData(
+            RQ_KEY(data.pageId),
+          ) as IPagination<IComment>;
+
+          if (currentComments && currentComments.items) {
+            const updatedComments = currentComments.items.map((comment) =>
+              comment.id === data.commentId
+                ? { 
+                    ...comment, 
+                    resolvedAt: data.resolvedAt, 
+                    resolvedById: data.resolvedById, 
+                    resolvedBy: data.resolvedBy 
+                  }
+                : comment,
+            );
+            
+            queryClient.setQueryData(RQ_KEY(data.pageId), {
+              ...currentComments,
+              items: updatedComments,
+            });
+          }
+          break;
+        }
       }
     });
   }, [queryClient, socket]);

apps/client/src/hooks/use-is-cloud-ee.tsx

@@ -0,0 +1,7 @@
+import { isCloud } from "@/lib/config";
+import { useLicense } from "@/ee/hooks/use-license";
+
+export const useIsCloudEE = () => {
+  const { hasLicenseKey } = useLicense();
+  return isCloud() || !!hasLicenseKey;
+}; 

apps/server/src/core/comment/comment.service.ts

@@ -22,6 +22,7 @@ export class CommentService {
   async findById(commentId: string) {
     const comment = await this.commentRepo.findById(commentId, {
       includeCreator: true,
+      includeResolvedBy: true,
     });
     if (!comment) {
       throw new NotFoundException('Comment not found');

apps/server/src/database/migrations/20250630T012831-add-resolved_by_id-to-comments.ts

@@ -0,0 +1,14 @@
+import { Kysely } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .alterTable('comments')
+    .addColumn('resolved_by_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('cascade'),
+    )
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.alterTable('comments').dropColumn('resolved_by_id').execute();
+}

apps/server/src/database/repos/comment/comment.repo.ts

@@ -20,12 +20,13 @@ export class CommentRepo {
   // todo, add workspaceId
   async findById(
     commentId: string,
-    opts?: { includeCreator: boolean },
+    opts?: { includeCreator: boolean; includeResolvedBy: boolean },
   ): Promise<Comment> {
     return await this.db
       .selectFrom('comments')
       .selectAll('comments')
       .$if(opts?.includeCreator, (qb) => qb.select(this.withCreator))
+      .$if(opts?.includeResolvedBy, (qb) => qb.select(this.withResolvedBy))
       .where('id', '=', commentId)
       .executeTakeFirst();
   }
@@ -35,6 +36,7 @@ export class CommentRepo {
       .selectFrom('comments')
       .selectAll('comments')
       .select((eb) => this.withCreator(eb))
+      .select((eb) => this.withResolvedBy(eb))
       .where('pageId', '=', pageId)
       .orderBy('createdAt', 'asc');
 
@@ -80,6 +82,15 @@ export class CommentRepo {
     ).as('creator');
   }
 
+  withResolvedBy(eb: ExpressionBuilder<DB, 'comments'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('users')
+        .select(['users.id', 'users.name', 'users.avatarUrl'])
+        .whereRef('users.id', '=', 'comments.resolvedById'),
+    ).as('resolvedBy');
+  }
+
   async deleteComment(commentId: string): Promise<void> {
     await this.db.deleteFrom('comments').where('id', '=', commentId).execute();
   }

apps/server/src/database/types/db.d.ts

@@ -122,6 +122,7 @@ export interface Comments {
   pageId: string;
   parentCommentId: string | null;
   resolvedAt: Timestamp | null;
+  resolvedById: string | null;
   selection: string | null;
   type: string | null;
   workspaceId: string;