core-framework 0.3.0__py3-none-any.whl

core_framework/domains/post/repository.py

@@ -0,0 +1,791 @@
+from datetime import datetime
+from typing import Any, Literal
+
+import orjson
+from asyncpg import Record
+
+from core_framework.core.database import Postgres
+from core_framework.domains.post.constants import REDACTED_CONTENT_PLACEHOLDER
+from core_framework.domains.post.enums import PostStatus, PostVisibility
+from core_framework.domains.post.exceptions import (
+    EditLimitReachedException,
+    PostNotFoundException,
+    PostUpdateNotFoundException,
+)
+from core_framework.domains.post.models import Post, PostPreview, PostStats, PostWithMetadata
+from core_framework.domains.user import REDACTED_AUTHOR_ID
+
+
+class PostRepository:
+    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_post(
+        self,
+        *,
+        post_id: str,
+        author_id: str,
+        content: str,
+        visibility: PostVisibility,
+        hashtags: list[str] | None = None,
+    ) -> None:
+        insert_post_query = """
+            insert into "post".posts (id, author_id, content, visibility)
+            values ($1, $2, $3, $4::"post".post_visibility)
+        """
+        insert_post_stats_query = """
+            insert into "post".post_stats (post_id)
+            values ($1)
+        """
+        insert_post_hashtags_query = """
+            insert into "post".post_hashtags (post_id, hashtag)
+            select $1, unnest($2::varchar[])
+        """
+        async with self.write_database.get_transaction() as connection:
+            await connection.execute(insert_post_query, post_id, author_id, content, visibility.value)
+            await connection.execute(insert_post_stats_query, post_id)
+            if hashtags:
+                await connection.execute(insert_post_hashtags_query, post_id, hashtags)
+
+    async def update_post(
+        self,
+        *,
+        post_id: str,
+        author_id: str,
+        post_updates: dict[str, Any],
+        hashtags: list[str] | None,
+        max_edit_count: int,
+    ) -> None:
+        allowed_fields = {
+            "content": "content",
+            "visibility": "visibility",
+        }
+        set_clauses = []
+        params: list[Any] = [post_id, author_id, max_edit_count]
+        content_param_index: int | None = None
+
+        for field, value in post_updates.items():
+            if field not in allowed_fields:
+                continue
+            if value is None:
+                continue
+            column = allowed_fields[field]
+            params.append(value)
+            if field == "visibility":
+                set_clauses.append(f'{column} = ${len(params)}::"post".post_visibility')
+            else:
+                content_param_index = len(params)
+                set_clauses.append(f"{column} = ${len(params)}")
+
+        if not set_clauses and hashtags is None:
+            return
+
+        if content_param_index is not None:
+            if hashtags is not None:
+                # Content and hashtags both present: bump when content changed or hashtags updated
+                params.append(True)
+                hashtags_param_index = len(params)
+                set_clauses.append(
+                    f"edited_count = case when p.content is distinct from ${content_param_index} or ${hashtags_param_index} "
+                    "then p.edited_count + 1 else p.edited_count end"
+                )
+                set_clauses.append(
+                    f"edited_at = case when p.content is distinct from ${content_param_index} or ${hashtags_param_index} then now() else p.edited_at end"
+                )
+            else:
+                # Content only: bump when content actually changed
+                set_clauses.append(
+                    f"edited_count = case when p.content is distinct from ${content_param_index} "
+                    "then p.edited_count + 1 else p.edited_count end"
+                )
+                set_clauses.append(
+                    f"edited_at = case when p.content is distinct from ${content_param_index} then now() else p.edited_at end"
+                )
+        elif hashtags is not None:
+            # Hashtags only: always bump
+            set_clauses.append("edited_count = p.edited_count + 1")
+            set_clauses.append("edited_at = now()")
+        set_clauses.append("updated_at = now()")
+
+        update_posts_query = f"""
+            with post_check as (
+                select
+                    id,
+                    edited_count
+                from "post".posts
+                where true
+                    and id = $1
+                    and author_id = $2
+                    and status = 'active'::"post".post_status
+            ),
+            update_result as (
+                update "post".posts p
+                set {", ".join(set_clauses)}
+                from post_check pc
+                where true
+                    and p.id = pc.id
+                    and pc.edited_count < $3
+                returning 1
+            )
+            select
+                (select count(*) from post_check) as found,
+                (select count(*) from update_result) as rows_updated
+        """
+        replace_post_hashtags_query = """
+            with target as (
+                select 1
+                from "post".posts p
+                where true
+                    and p.id = $1
+                    and p.author_id = $2
+                    and p.status = 'active'::"post".post_status
+                    and p.edited_count < $4
+            ),
+            deleted as (
+                delete from "post".post_hashtags ph
+                using target
+                where true
+                    and ph.post_id = $1
+                    and ph.hashtag <> all($3::varchar[])
+                returning 1
+            ),
+            inserted as (
+                insert into "post".post_hashtags (post_id, hashtag)
+                select $1, t
+                from target, unnest($3::varchar[]) as t
+                on conflict (post_id, hashtag) do nothing
+                returning 1
+            )
+            select 1
+            from target
+        """
+
+        async with self.write_database.get_transaction() as connection:
+            row = await connection.fetchrow(update_posts_query, *params)
+            if row["found"] == 0:
+                raise PostUpdateNotFoundException()
+            if row["rows_updated"] == 0:
+                raise EditLimitReachedException()
+            if hashtags is not None:
+                await connection.execute(
+                    replace_post_hashtags_query,
+                    post_id,
+                    author_id,
+                    hashtags,
+                    max_edit_count,
+                )
+
+    async def update_post_status_by_id_and_author(
+        self,
+        *,
+        post_id: str,
+        author_id: str,
+        status: PostStatus,
+    ) -> None:
+        query = """
+            update "post".posts
+            set
+                status = $3::"post".post_status,
+                updated_at = now()
+            where true
+                and id = $1
+                and author_id = $2
+                and status != $3::"post".post_status
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, post_id, author_id, status.value)
+
+    async def update_post_status_by_id(self, *, post_id: str, status: PostStatus) -> bool:
+        query = """
+            update "post".posts
+            set
+                status = $2::"post".post_status,
+                updated_at = now()
+            where id = $1
+            returning 1
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(query, post_id, status.value)
+            return row is not None
+
+    async def delete_post_by_id(self, *, post_id: str) -> bool:
+        query = """
+            delete from "post".posts
+            where id = $1
+            returning 1
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(query, post_id)
+            return row is not None
+
+    async def insert_user_restriction_lookup(
+        self,
+        *,
+        user_id: str,
+        restriction_type: Literal["muted", "banned"],
+    ) -> None:
+        query = """
+            merge into "post".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 "post".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 "post".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 "post".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:
+        delete_hashtags_for_author_query = """
+            delete from "post".post_hashtags ph
+            using "post".posts p
+            where true
+                and ph.post_id = p.id
+                and p.author_id = $1
+        """
+        redact_posts_query = """
+            update "post".posts
+            set
+                content = $2,
+                author_id = $3,
+                updated_at = now()
+            where true
+                and author_id = $1
+        """
+        delete_restrictions_query = """
+            delete from "post".user_restrictions_lookup
+            where true
+                and user_id = $1
+        """
+        delete_blocks_query = """
+            delete from "post".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(delete_hashtags_for_author_query, user_id)
+            await connection.execute(
+                redact_posts_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 select_post_with_metadata_by_id(self, *, post_id: str) -> PostWithMetadata:
+        query = """
+            select
+                id,
+                author_id,
+                content,
+                visibility,
+                status,
+                edited_count,
+                edited_at,
+                created_at
+            from "post".posts
+            where id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            row = await connection.fetchrow(query, post_id)
+            if row is None:
+                raise PostNotFoundException()
+            return PostWithMetadata(
+                id=row["id"],
+                author_id=row["author_id"],
+                content=row["content"],
+                visibility=PostVisibility(row["visibility"]),
+                status=PostStatus(row["status"]),
+                edited_count=row["edited_count"],
+                edited_at=row["edited_at"],
+                created_at=row["created_at"],
+            )
+
+    async def select_post_by_id(self, *, post_id: str, viewer_id: str | None) -> Post | None:
+        query = """
+            select
+                p.id,
+                p.author_id,
+                p.content,
+                p.visibility,
+                p.edited_count,
+                p.edited_at,
+                p.created_at
+            from "post".posts p
+            where true
+                and p.id = $1
+                and p.status = 'active'::"post".post_status
+                and (
+                    $2::varchar is null
+                    or not exists(
+                        select 1
+                        from "post".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $2
+                            and b.blocked_id = p.author_id
+                    )
+                )
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetchrow(query, post_id, viewer_id)
+            if result is None:
+                return None
+            return self._map_post_row(result)
+
+    async def select_posts(
+        self,
+        *,
+        viewer_id: str | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[Post]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "post".user_restrictions_lookup
+                    where true
+                        and user_id = $1
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                p.id,
+                p.author_id,
+                p.content,
+                p.visibility,
+                p.edited_count,
+                p.edited_at,
+                p.created_at
+            from "post".posts p
+            left join "post".user_restrictions_lookup r
+                on r.user_id = p.author_id
+            cross join viewer_context vc
+            where true
+                and p.status = 'active'::"post".post_status
+                and p.created_at <= $2
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $1 is not null
+                        and vc.is_viewer_muted
+                        and p.author_id = $1
+                    )
+                )
+                and (
+                    $1 is null
+                    or not exists(
+                        select 1
+                        from "post".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $1
+                            and b.blocked_id = p.author_id
+                    )
+                )
+            order by p.created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, viewer_id, cursor, limit)
+            return [self._map_post_row(row) for row in result]
+
+    async def select_posts_by_user_id(
+        self,
+        *,
+        user_id: str,
+        cursor: datetime,
+        limit: int,
+        viewer_id: str | None,
+    ) -> list[Post]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "post".user_restrictions_lookup
+                    where true
+                        and user_id = $4
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                p.id,
+                p.author_id,
+                p.content,
+                p.visibility,
+                p.edited_count,
+                p.edited_at,
+                p.created_at
+            from "post".posts p
+            left join "post".user_restrictions_lookup r
+                on r.user_id = p.author_id
+            cross join viewer_context vc
+            where true
+                and p.author_id = $1
+                and p.status = 'active'::"post".post_status
+                and p.created_at <= $2
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $4 is not null
+                        and vc.is_viewer_muted
+                        and p.author_id = $4
+                    )
+                )
+                and (
+                    $4::varchar is null
+                    or not exists(
+                        select 1
+                        from "post".user_blocks_lookup
+                        where true
+                            and blocker_id = $4
+                            and blocked_id = $1
+                    )
+                )
+            order by p.created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, user_id, cursor, limit, viewer_id)
+            return [self._map_post_row(row) for row in result]
+
+    async def select_posts_by_hashtag(
+        self,
+        *,
+        hashtag: str,
+        cursor: datetime,
+        limit: int,
+        viewer_id: str | None,
+    ) -> list[Post]:
+        query = """
+            with viewer_context as (
+                select exists(
+                    select 1
+                    from "post".user_restrictions_lookup
+                    where true
+                        and user_id = $4
+                        and restriction_type = 'muted'
+                ) as is_viewer_muted
+            )
+            select
+                p.id,
+                p.author_id,
+                p.content,
+                p.visibility,
+                p.edited_count,
+                p.edited_at,
+                p.created_at
+            from "post".posts p
+            join "post".post_hashtags ph on ph.post_id = p.id and ph.hashtag = $1
+            left join "post".user_restrictions_lookup r on r.user_id = p.author_id
+            cross join viewer_context vc
+            where true
+                and p.status = 'active'::"post".post_status
+                and p.created_at <= $2
+                and (
+                    r.user_id is null
+                    or (
+                        r.restriction_type = 'muted'
+                        and $4 is not null
+                        and vc.is_viewer_muted
+                        and p.author_id = $4
+                    )
+                )
+                and (
+                    $4::varchar is null
+                    or not exists(
+                        select 1
+                        from "post".user_blocks_lookup b
+                        where true
+                            and b.blocker_id = $4
+                            and b.blocked_id = p.author_id
+                    )
+                )
+            order by p.created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, hashtag, cursor, limit, viewer_id)
+            return [self._map_post_row(row) for row in result]
+
+    async def select_posts_unfiltered(
+        self,
+        *,
+        cursor: datetime,
+        limit: int,
+    ) -> list[PostWithMetadata]:
+        query = """
+            select
+                id,
+                author_id,
+                content,
+                visibility,
+                status,
+                edited_count,
+                edited_at,
+                created_at
+            from "post".posts
+            where true
+                and created_at <= $1
+            order by created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit)
+            return [
+                PostWithMetadata(
+                    id=row["id"],
+                    author_id=row["author_id"],
+                    content=row["content"],
+                    visibility=PostVisibility(row["visibility"]),
+                    status=PostStatus(row["status"]),
+                    edited_count=row["edited_count"],
+                    edited_at=row["edited_at"],
+                    created_at=row["created_at"],
+                )
+                for row in result
+            ]
+
+    async def insert_post_like(self, *, post_id: str, liker_id: str) -> None:
+        query = """
+            insert into "post".post_likes (post_id, liker_id)
+            select
+                $1::varchar,
+                $2::varchar
+            where exists (
+                select 1
+                from "post".posts
+                where true
+                    and id = $1::varchar
+                    and status = 'active'::"post".post_status
+            )
+            on conflict (post_id, liker_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, post_id, liker_id)
+
+    async def delete_post_like(self, *, post_id: str, liker_id: str) -> None:
+        query = """
+            delete from "post".post_likes
+            where true
+                and post_id = $1
+                and liker_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, post_id, liker_id)
+
+    async def select_post_like_count(self, *, post_id: str) -> int:
+        query = """
+            select count(*)
+            from "post".post_likes
+            where post_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            return await connection.fetchval(query, post_id)
+
+    async def select_post_ids_liked_by_user(self, *, liker_id: str, post_ids: set[str]) -> list[str]:
+        if not post_ids:
+            return []
+        query = """
+            select post_id
+            from "post".post_likes
+            where true
+                and liker_id = $1
+                and post_id = any($2)
+        """
+        async with self.read_database.get_connection() as connection:
+            rows = await connection.fetch(query, liker_id, list(post_ids))
+            return [row["post_id"] for row in rows]
+
+    async def insert_post_view(
+        self,
+        *,
+        post_id: str,
+        token: str,
+        request_context: dict[str, str],
+    ) -> None:
+        query = """
+            insert into "post".post_views (post_id, token, request_context)
+            values ($1, $2, $3::jsonb)
+            on conflict (post_id, token) do nothing
+        """
+        json_value = orjson.dumps(request_context).decode()
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, post_id, token, json_value)
+
+    async def aggregate_post_view_counts(self) -> list[str]:
+        query = """
+            with new_counts as (
+                select
+                    pv.post_id,
+                    count(*) as new_views
+                from "post".post_views pv
+                join "post".post_stats ps on ps.post_id = pv.post_id
+                where pv.created_at > coalesce(ps.view_count_aggregated_at, '1970-01-01'::timestamptz)
+                group by pv.post_id
+            )
+            update "post".post_stats ps
+            set
+                view_count = ps.view_count + nc.new_views,
+                view_count_aggregated_at = now()
+            from new_counts nc
+            where ps.post_id = nc.post_id
+            returning ps.post_id
+        """
+        async with self.write_database.get_connection() as connection:
+            rows = await connection.fetch(query)
+            return [row["post_id"] for row in rows]
+
+    async def update_post_stats(
+        self,
+        *,
+        post_id: str,
+        like_count: int,
+        comment_count: int,
+        report_count: int,
+    ) -> None:
+        query = """
+            update "post".post_stats
+            set
+                like_count = $2,
+                comment_count = $3,
+                report_count = $4,
+                updated_at = now()
+            where post_id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(
+                query,
+                post_id,
+                like_count,
+                comment_count,
+                report_count,
+            )
+
+    async def select_post_stats_mapping(self, *, post_ids: set[str]) -> dict[str, PostStats]:
+        if not post_ids:
+            return {}
+
+        query = """
+            select
+                post_id,
+                like_count,
+                comment_count,
+                view_count,
+                report_count
+            from "post".post_stats
+            where post_id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(post_ids))
+            return {
+                row["post_id"]: PostStats(
+                    like_count=row["like_count"],
+                    comment_count=row["comment_count"],
+                    view_count=row["view_count"],
+                    report_count=row["report_count"],
+                )
+                for row in result
+            }
+
+    async def select_post_content_mapping(self, *, post_ids: set[str]) -> dict[str, str]:
+        if not post_ids:
+            return {}
+        query = """
+            select id, content
+            from "post".posts
+            where id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(post_ids))
+            return {row["id"]: row["content"] or "" for row in result}
+
+    async def select_post_preview_mapping(self, *, post_ids: set[str]) -> dict[str, PostPreview]:
+        if not post_ids:
+            return {}
+        query = """
+            select
+                id,
+                author_id,
+                content
+            from "post".posts
+            where id = any($1::varchar[])
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(post_ids))
+            return {
+                row["id"]: PostPreview(
+                    id=row["id"],
+                    author_id=row["author_id"],
+                    content=row["content"],
+                )
+                for row in result
+            }
+
+    async def select_hashtags_mapping(self, *, post_ids: set[str]) -> dict[str, list[str]]:
+        if not post_ids:
+            return {}
+
+        query = """
+            select
+                post_id,
+                array_agg(hashtag order by created_at) as hashtags
+            from "post".post_hashtags
+            where post_id = any($1::varchar[])
+            group by post_id
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, list(post_ids))
+            return {row["post_id"]: list(row["hashtags"]) for row in result}
+
+    def _map_post_row(self, row: Record) -> Post:
+        return Post(
+            id=row["id"],
+            author_id=row["author_id"],
+            content=row["content"],
+            visibility=PostVisibility(row["visibility"]),
+            edited_count=row["edited_count"],
+            edited_at=row["edited_at"],
+            created_at=row["created_at"],
+        )