core-framework 0.3.0__py3-none-any.whl

core_framework/domains/comment/repository.py

@@ -0,0 +1,947 @@
+from datetime import datetime
+from typing import Any, Literal
+
+from asyncpg import Record
+
+from core_framework.core.database import Postgres
+from core_framework.domains.comment.constants import REDACTED_CONTENT_PLACEHOLDER
+from core_framework.domains.comment.enums import CommentStatus, CommentSubjectType
+from core_framework.domains.comment.exceptions import (
+    BaseCommentException,
+    CommentEditLimitReachedException,
+    CommentNotFoundException,
+    CommentUpdateNotFoundException,
+    MaxReplyDepthException,
+    ParentCommentNotFoundException,
+)
+from core_framework.domains.comment.models import Comment, CommentPreview, CommentStats, CommentWithMetadata
+from core_framework.domains.user import REDACTED_AUTHOR_ID
+
+
+class CommentRepository:
+    def __init__(self, write_database: Postgres, read_database: Postgres, strong_read_database: Postgres):
+        self.write_database = write_database
+        self.read_database = read_database
+        self.strong_read_database = strong_read_database
+
+    async def insert_comment(
+        self,
+        *,
+        comment_id: str,
+        author_id: str,
+        content: str,
+        subject_type: CommentSubjectType,
+        subject_id: str,
+    ) -> None:
+        insert_root_comment_query = """
+            insert into "comment".comments (
+                id,
+                author_id,
+                content,
+                subject_type,
+                subject_id,
+                path,
+                level
+            )
+            values (
+                $3,
+                $4,
+                $5,
+                $1::"comment".comment_subject_type,
+                $2,
+                text2ltree($6::text),
+                0
+            )
+        """
+        insert_comment_stats_query = """
+            insert into "comment".comment_stats (comment_id)
+            values ($1)
+        """
+        async with self.write_database.get_transaction() as connection:
+            await connection.execute(
+                insert_root_comment_query,
+                subject_type.value,
+                subject_id,
+                comment_id,
+                author_id,
+                content,
+                comment_id,
+            )
+            await connection.execute(insert_comment_stats_query, comment_id)
+
+    async def insert_reply(
+        self,
+        *,
+        comment_id: str,
+        author_id: str,
+        content: str,
+        parent_comment_id: str,
+        max_reply_level: int,
+    ) -> None:
+        insert_reply_query = """
+            with parent_check as (
+                select id, status, level, path, subject_type, subject_id
+                from "comment".comments
+                where id = $1
+            ),
+            outcome as (
+                select
+                    case
+                        when not exists (select 1 from parent_check) then 'parent_not_found'
+                        when (select status from parent_check limit 1) != 'active' then 'parent_not_found'
+                        when (select level from parent_check limit 1) >= $2 then 'max_depth'
+                        else 'ok'
+                    end as result
+            ),
+            valid_parent as (
+                select path, level, subject_type, subject_id
+                from parent_check
+                where status = 'active' and level < $2
+            ),
+            insert_result as (
+                insert into "comment".comments (
+                    id,
+                    author_id,
+                    content,
+                    subject_type,
+                    subject_id,
+                    parent_comment_id,
+                    path,
+                    level
+                )
+                select
+                    $3,
+                    $4,
+                    $5,
+                    p.subject_type,
+                    p.subject_id,
+                    $1,
+                    p.path || $6::text,
+                    p.level + 1
+                from valid_parent p
+                returning id
+            )
+            select
+                (select id from insert_result limit 1) as inserted_id,
+                coalesce(
+                    (select 'ok' from insert_result limit 1),
+                    (select result from outcome)
+                ) as outcome
+        """
+        insert_comment_stats_query = """
+            insert into "comment".comment_stats (comment_id)
+            values ($1)
+        """
+        async with self.write_database.get_transaction() as connection:
+            row = await connection.fetchrow(
+                insert_reply_query,
+                parent_comment_id,
+                max_reply_level,
+                comment_id,
+                author_id,
+                content,
+                comment_id,
+            )
+            match row["outcome"]:
+                case "ok":
+                    await connection.execute(insert_comment_stats_query, comment_id)
+                    return
+                case "max_depth":
+                    raise MaxReplyDepthException()
+                case "parent_not_found":
+                    raise ParentCommentNotFoundException()
+                case _:
+                    raise BaseCommentException("Unexpected reply insert outcome")
+
+    async def insert_user_restriction_lookup(
+        self,
+        *,
+        user_id: str,
+        restriction_type: Literal["muted", "banned"],
+    ) -> None:
+        query = """
+            merge into "comment".user_restrictions_lookup as target
+            using (values ($1, $2)) as source(user_id, restriction_type)
+            on target.user_id = source.user_id
+            when matched then
+                update set restriction_type = source.restriction_type
+            when not matched then
+                insert (user_id, restriction_type)
+                values (source.user_id, source.restriction_type)
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, user_id, restriction_type)
+
+    async def delete_user_restriction_lookup(self, *, user_id: str) -> None:
+        query = """
+            delete from "comment".user_restrictions_lookup
+            where true
+                and user_id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, user_id)
+
+    async def insert_user_block_lookup(self, *, blocker_id: str, blocked_id: str) -> None:
+        query = """
+            merge into "comment".user_blocks_lookup as target
+            using (values ($1, $2)) as source(blocker_id, blocked_id)
+            on target.blocker_id = source.blocker_id
+                and target.blocked_id = source.blocked_id
+            when not matched then
+                insert (blocker_id, blocked_id)
+                values (source.blocker_id, source.blocked_id)
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, blocker_id, blocked_id)
+
+    async def delete_user_block_lookup(self, *, blocker_id: str, blocked_id: str) -> None:
+        query = """
+            delete from "comment".user_blocks_lookup
+            where true
+                and blocker_id = $1
+                and blocked_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, blocker_id, blocked_id)
+
+    async def delete_user(self, *, user_id: str) -> None:
+        redact_comments_query = """
+            update "comment".comments
+            set
+                content = $2,
+                author_id = $3,
+                updated_at = now()
+            where true
+                and author_id = $1
+        """
+        delete_restrictions_query = """
+            delete from "comment".user_restrictions_lookup
+            where true
+                and user_id = $1
+        """
+        delete_blocks_query = """
+            delete from "comment".user_blocks_lookup
+            where true
+                and (
+                    blocker_id = $1
+                    or blocked_id = $1
+                )
+        """
+        async with self.write_database.get_transaction() as connection:
+            await connection.execute(
+                redact_comments_query,
+                user_id,
+                REDACTED_CONTENT_PLACEHOLDER,
+                REDACTED_AUTHOR_ID,
+            )
+            await connection.execute(delete_restrictions_query, user_id)
+            await connection.execute(delete_blocks_query, user_id)
+
+    async def insert_comment_like(self, *, comment_id: str, liker_id: str) -> None:
+        query = """
+            insert into "comment".comment_likes (comment_id, liker_id)
+            select
+                $1::varchar,
+                $2::varchar
+            where exists (
+                select 1
+                from "comment".comments
+                where true
+                    and id = $1::varchar
+                    and status = 'active'::"comment".comment_status
+            )
+            on conflict (comment_id, liker_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, comment_id, liker_id)
+
+    async def delete_comment_like(self, *, comment_id: str, liker_id: str) -> None:
+        query = """
+            delete from "comment".comment_likes
+            where true
+                and comment_id = $1
+                and liker_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, comment_id, liker_id)
+
+    async def update_comment(
+        self,
+        *,
+        comment_id: str,
+        author_id: str,
+        comment_updates: dict[str, Any],
+        max_edit_count: int,
+    ) -> None:
+        content = comment_updates.get("content")
+        if content is None:
+            return
+
+        query = """
+            with comment_check as (
+                select
+                    id,
+                    edited_count
+                from "comment".comments
+                where true
+                    and id = $1
+                    and author_id = $2
+                    and status = 'active'::"comment".comment_status
+            ),
+            update_result as (
+                update "comment".comments c
+                set
+                    content = $3,
+                    edited_count = case when c.content is distinct from $3
+                        then c.edited_count + 1 else c.edited_count end,
+                    edited_at = case when c.content is distinct from $3
+                        then now() else c.edited_at end,
+                    updated_at = now()
+                from comment_check cc
+                where true
+                    and c.id = cc.id
+                    and cc.edited_count < $4
+                returning 1
+            )
+            select
+                (select count(*) from comment_check) as found,
+                (select count(*) from update_result) as rows_updated
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(
+                query,
+                comment_id,
+                author_id,
+                content,
+                max_edit_count,
+            )
+            if row["found"] == 0:
+                raise CommentUpdateNotFoundException()
+            if row["rows_updated"] == 0:
+                raise CommentEditLimitReachedException()
+
+    async def update_comment_status_by_id_and_author(
+        self,
+        *,
+        comment_id: str,
+        author_id: str,
+        status: CommentStatus,
+    ) -> str | None:
+        query = """
+            with upd as (
+                update "comment".comments
+                set
+                    status = $3::"comment".comment_status,
+                    updated_at = now()
+                where true
+                    and id = $1
+                    and author_id = $2
+                    and status != $3::"comment".comment_status
+                returning id, parent_comment_id
+            ),
+            removed_dirty as (
+                delete from "comment".comment_stats_dirty d
+                using upd
+                where d.comment_id = upd.id
+            )
+            select parent_comment_id from upd
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(query, comment_id, author_id, status.value)
+            return row["parent_comment_id"] if row else None
+
+    async def update_comment_status_by_id(
+        self,
+        *,
+        comment_id: str,
+        status: CommentStatus,
+    ) -> str | None:
+        query = """
+            with upd as (
+                update "comment".comments
+                set
+                    status = $2::"comment".comment_status,
+                    updated_at = now()
+                where id = $1
+                returning id, parent_comment_id
+            ),
+            removed_dirty as (
+                delete from "comment".comment_stats_dirty d
+                using upd
+                where d.comment_id = upd.id
+            )
+            select parent_comment_id from upd
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(query, comment_id, status.value)
+            if row is None:
+                raise CommentNotFoundException()
+            return row["parent_comment_id"]
+
+    async def select_comment_ids_by_subject_strong(
+        self,
+        *,
+        subject_type: CommentSubjectType,
+        subject_id: str,
+    ) -> set[str]:
+        query = """
+            select id
+            from "comment".comments
+            where true
+                and subject_type = $1::"comment".comment_subject_type
+                and subject_id = $2
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            rows = await connection.fetch(query, subject_type.value, subject_id)
+            return {row["id"] for row in rows}
+
+    async def select_active_comment_count_for_post(self, *, post_id: str) -> int:
+        # Active rows only if no soft-deleted ancestor on this post (a.path @> c.path).
+        query = """
+            select count(*)
+            from "comment".comments c
+            where true
+                and c.subject_type = 'post'::"comment".comment_subject_type
+                and c.subject_id = $1
+                and c.status = 'active'::"comment".comment_status
+                and not exists (
+                    select 1
+                    from "comment".comments a
+                    where true
+                        and a.subject_type = 'post'::"comment".comment_subject_type
+                        and a.subject_id = $1
+                        and a.path @> c.path
+                        and a.status = 'deleted'::"comment".comment_status
+                )
+        """
+        async with self.read_database.get_connection() as connection:
+            value = await connection.fetchval(query, post_id)
+            return int(value or 0)
+
+    async def select_comment_subtree_ids_strong(self, *, root_comment_id: str) -> set[str]:
+        query = """
+            with root_comment as (
+                select subject_type, subject_id, path
+                from "comment".comments
+                where id = $1
+            )
+            select c.id
+            from "comment".comments c
+            join root_comment r
+                on c.subject_type = r.subject_type
+                and c.subject_id = r.subject_id
+                and c.path <@ r.path
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            rows = await connection.fetch(query, root_comment_id)
+            return {row["id"] for row in rows}
+
+    async def select_parent_comment_id_strong(self, *, comment_id: str) -> str | None:
+        query = """
+            select parent_comment_id
+            from "comment".comments
+            where id = $1
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            return await connection.fetchval(query, comment_id)
+
+    async def delete_comment_subtree(self, *, root_comment_id: str) -> None:
+        query = """
+            delete from "comment".comments
+            where id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, root_comment_id)
+
+    async def delete_comments_by_subject(
+        self,
+        *,
+        subject_type: CommentSubjectType,
+        subject_id: str,
+    ) -> None:
+        query = """
+            delete from "comment".comments
+            where true
+                and subject_type = $1::"comment".comment_subject_type
+                and subject_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, subject_type.value, subject_id)
+
+    async def select_comment_ids_liked_by_user(self, *, liker_id: str, comment_ids: set[str]) -> list[str]:
+        if not comment_ids:
+            return []
+        query = """
+            select comment_id
+            from "comment".comment_likes
+            where true
+                and liker_id = $1
+                and comment_id = any($2::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            rows = await connection.fetch(query, liker_id, list(comment_ids))
+            return [row["comment_id"] for row in rows]
+
+    async def select_comment_content_mapping(self, *, comment_ids: set[str]) -> dict[str, str]:
+        if not comment_ids:
+            return {}
+        query = """
+            select id, content
+            from "comment".comments
+            where id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(comment_ids))
+            return {row["id"]: row["content"] or "" for row in result}
+
+    async def select_comment_stats_mapping(self, *, comment_ids: set[str]) -> dict[str, CommentStats]:
+        if not comment_ids:
+            return {}
+        query = """
+            select
+                comment_id,
+                like_count,
+                reply_count,
+                report_count
+            from "comment".comment_stats
+            where comment_id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(comment_ids))
+            return {
+                row["comment_id"]: CommentStats(
+                    like_count=row["like_count"],
+                    reply_count=row["reply_count"],
+                    report_count=row["report_count"],
+                )
+                for row in result
+            }
+
+    async def insert_comment_stats_dirty(self, *, comment_id: str) -> None:
+        query = """
+            insert into "comment".comment_stats_dirty (comment_id)
+            values ($1)
+            on conflict (comment_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, comment_id)
+
+    async def claim_comment_ids_dirty(self) -> list[str]:
+        query = """
+            delete from "comment".comment_stats_dirty
+            returning comment_id
+        """
+        async with self.write_database.get_transaction() as connection:
+            rows = await connection.fetch(query)
+        return [row["comment_id"] for row in rows]
+
+    async def delete_comment_stats_dirty(self, *, comment_ids: set[str]) -> None:
+        if not comment_ids:
+            return
+        query = """
+            delete from "comment".comment_stats_dirty
+            where comment_id = any($1::varchar[])
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, list(comment_ids))
+
+    async def update_comment_stats(
+        self,
+        *,
+        comment_id: str,
+        like_count: int,
+        reply_count: int,
+        report_count: int,
+    ) -> None:
+        query = """
+            update "comment".comment_stats
+            set
+                like_count = $2,
+                reply_count = $3,
+                report_count = $4,
+                updated_at = now()
+            where comment_id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(
+                query,
+                comment_id,
+                like_count,
+                reply_count,
+                report_count,
+            )
+
+    async def select_comment_like_count(self, *, comment_id: str) -> int:
+        query = """
+            select count(*)
+            from "comment".comment_likes
+            where comment_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            return await connection.fetchval(query, comment_id) or 0
+
+    async def select_comment_reply_count(self, *, comment_id: str) -> int:
+        query = """
+            select count(*)
+            from "comment".comments
+            where true
+                and parent_comment_id = $1
+                and status = 'active'::"comment".comment_status
+        """
+        async with self.read_database.get_connection() as connection:
+            return await connection.fetchval(query, comment_id) or 0
+
+    async def select_comments_with_metadata(
+        self,
+        *,
+        cursor: datetime,
+        limit: int,
+    ) -> list[CommentWithMetadata]:
+        query = """
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.subject_type,
+                c.subject_id,
+                c.parent_comment_id,
+                c.status,
+                c.edited_count,
+                c.edited_at,
+                c.created_at
+            from "comment".comments c
+            where true
+                and c.created_at <= $1
+            order by c.created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit)
+            return [self._map_comment_with_metadata_row(row) for row in result]
+
+    async def select_comment_with_metadata_by_id(self, *, comment_id: str) -> CommentWithMetadata:
+        query = """
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.subject_type,
+                c.subject_id,
+                c.parent_comment_id,
+                c.status,
+                c.edited_count,
+                c.edited_at,
+                c.created_at
+            from "comment".comments c
+            where c.id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            row = await connection.fetchrow(query, comment_id)
+            if row is None:
+                raise CommentNotFoundException()
+            return self._map_comment_with_metadata_row(row)
+
+    async def select_comment_preview_mapping(self, *, comment_ids: set[str]) -> dict[str, CommentPreview]:
+        if not comment_ids:
+            return {}
+        query = """
+            select
+                id,
+                author_id,
+                content,
+                status
+            from "comment".comments
+            where id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(comment_ids))
+            return {row["id"]: self._map_comment_preview_row(row) for row in result}
+
+    async def select_comments_by_subject(
+        self,
+        *,
+        subject_type: CommentSubjectType,
+        subject_id: str,
+        cursor: datetime,
+        limit: int,
+        viewer_id: str | None,
+    ) -> list[Comment]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "comment".user_restrictions_lookup
+                    where true
+                        and user_id = $3
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.edited_count,
+                c.edited_at,
+                c.level,
+                c.created_at
+            from "comment".comments c
+            left join "comment".user_restrictions_lookup r
+                on r.user_id = c.author_id
+            cross join viewer_context vc
+            where true
+                and c.subject_type = $1::"comment".comment_subject_type
+                and c.subject_id = $2
+                and c.status = 'active'::"comment".comment_status
+                and c.created_at <= $4
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $3 is not null
+                        and vc.is_viewer_muted
+                        and c.author_id = $3
+                    )
+                )
+                and (
+                    $3 is null
+                    or not exists(
+                        select 1
+                        from "comment".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $3
+                            and b.blocked_id = c.author_id
+                    )
+                )
+            order by c.created_at desc
+            limit $5
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(
+                query,
+                subject_type.value,
+                subject_id,
+                viewer_id,
+                cursor,
+                limit,
+            )
+            return [self._map_comment_row(row) for row in result]
+
+    async def select_comments_by_author_id(
+        self,
+        *,
+        author_id: str,
+        cursor: datetime,
+        limit: int,
+        viewer_id: str | None,
+    ) -> list[Comment]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "comment".user_restrictions_lookup
+                    where true
+                        and user_id = $2
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.edited_count,
+                c.edited_at,
+                c.level,
+                c.created_at
+            from "comment".comments c
+            left join "comment".user_restrictions_lookup r
+                on r.user_id = c.author_id
+            cross join viewer_context vc
+            where true
+                and c.author_id = $1
+                and c.status = 'active'::"comment".comment_status
+                and c.created_at <= $3
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $2 is not null
+                        and vc.is_viewer_muted
+                        and c.author_id = $2
+                    )
+                )
+                and (
+                    $2 is null
+                    or not exists(
+                        select 1
+                        from "comment".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $2
+                            and b.blocked_id = c.author_id
+                    )
+                )
+            order by c.created_at desc
+            limit $4
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(
+                query,
+                author_id,
+                viewer_id,
+                cursor,
+                limit,
+            )
+            return [self._map_comment_row(row) for row in result]
+
+    async def select_replies_by_parent_id(
+        self,
+        *,
+        parent_comment_id: str,
+        cursor: datetime,
+        limit: int,
+        viewer_id: str | None,
+    ) -> list[Comment]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "comment".user_restrictions_lookup
+                    where true
+                        and user_id = $2
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.edited_count,
+                c.edited_at,
+                c.level,
+                c.created_at
+            from "comment".comments c
+            left join "comment".user_restrictions_lookup r
+                on r.user_id = c.author_id
+            cross join viewer_context vc
+            where true
+                and c.parent_comment_id = $1
+                and c.status = 'active'::"comment".comment_status
+                and c.created_at <= $3
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $2 is not null
+                        and vc.is_viewer_muted
+                        and c.author_id = $2
+                    )
+                )
+                and (
+                    $2 is null
+                    or not exists(
+                        select 1
+                        from "comment".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $2
+                            and b.blocked_id = c.author_id
+                    )
+                )
+            order by c.created_at desc
+            limit $4
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(
+                query,
+                parent_comment_id,
+                viewer_id,
+                cursor,
+                limit,
+            )
+            return [self._map_comment_row(row) for row in result]
+
+    async def select_comment_by_id(
+        self,
+        *,
+        comment_id: str,
+        viewer_id: str | None,
+    ) -> Comment | None:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "comment".user_restrictions_lookup
+                    where true
+                        and user_id = $2
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                c.id,
+                c.author_id,
+                c.content,
+                c.edited_count,
+                c.edited_at,
+                c.level,
+                c.created_at
+            from "comment".comments c
+            left join "comment".user_restrictions_lookup r
+                on r.user_id = c.author_id
+            cross join viewer_context vc
+            where true
+                and c.id = $1
+                and c.status = 'active'::"comment".comment_status
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $2 is not null
+                        and vc.is_viewer_muted
+                        and c.author_id = $2
+                    )
+                )
+                and (
+                    $2 is null
+                    or not exists(
+                        select 1
+                        from "comment".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $2
+                            and b.blocked_id = c.author_id
+                    )
+                )
+        """
+        async with self.read_database.get_connection() as connection:
+            row = await connection.fetchrow(query, comment_id, viewer_id)
+            return self._map_comment_row(row) if row is not None else None
+
+    def _map_comment_row(self, row: Record) -> Comment:
+        return Comment(
+            id=row["id"],
+            author_id=row["author_id"],
+            content=row["content"],
+            edited_count=row["edited_count"],
+            edited_at=row["edited_at"],
+            level=row["level"],
+            created_at=row["created_at"],
+        )
+
+    def _map_comment_with_metadata_row(self, row: Record) -> CommentWithMetadata:
+        return CommentWithMetadata(
+            id=row["id"],
+            author_id=row["author_id"],
+            content=row["content"],
+            subject_type=CommentSubjectType(row["subject_type"]),
+            subject_id=row["subject_id"],
+            parent_comment_id=row["parent_comment_id"],
+            status=CommentStatus(row["status"]),
+            edited_count=row["edited_count"],
+            edited_at=row["edited_at"],
+            created_at=row["created_at"],
+        )
+
+    def _map_comment_preview_row(self, row: Record) -> CommentPreview:
+        return CommentPreview(
+            id=row["id"],
+            author_id=row["author_id"],
+            content=row["content"] or "",
+            status=CommentStatus(row["status"]),
+        )