core-framework 0.3.0__py3-none-any.whl

core_framework/domains/user/repository.py

@@ -0,0 +1,612 @@
+from datetime import datetime
+from typing import Any
+
+import asyncpg
+import orjson
+
+from core_framework.core.database import Postgres
+from core_framework.domains.user.enums import UserRole
+from core_framework.domains.user.exceptions import (
+    DomainUserNotFoundException,
+    SelfBlockException,
+    UserCreationException,
+    UserIdConflictException,
+    UsernameConflictException,
+)
+from core_framework.domains.user.models import (
+    BlockedUser,
+    Preferences,
+    Profile,
+    UserChangeHistory,
+    UserIdentity,
+    UserWithProfile,
+)
+
+
+class UserRepository:
+    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
+
+    # User Management
+    async def select_admin_user_ids(self) -> set[str]:
+        query = """
+            select
+                user_id
+            from "user".users
+            where true
+            and role = 'admin'
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query)
+            return {record["user_id"] for record in result}
+
+    async def insert_user(self, *, user_id: str, username: str, role: str) -> None:
+        user_query = """
+            with attempt as (
+                merge into "user".users as target
+                using (values ($1, $2, $3::"user".user_role)) as source(user_id, username, role)
+                on target.user_id = source.user_id
+                    or target.username = source.username
+                when matched then
+                    do nothing
+                when not matched then
+                    insert (user_id, username, role)
+                    values (source.user_id, source.username, source.role)
+                returning 1 as inserted
+            )
+            select
+            case
+                when exists (select 1 from attempt) then 'INSERTED'
+                when exists (select 1 from "user".users u where u.user_id = $1) then 'USER_ID_CONFLICT'
+                when exists (select 1 from "user".users u where u.username = $2) then 'USERNAME_CONFLICT'
+                else 'UNKNOWN'
+            end as result;
+        """
+        profile_query = """
+            insert into "user".user_profiles (user_id) values ($1)
+        """
+        preferences_query = """
+            insert into "user".user_preferences (user_id) values ($1)
+        """
+        async with self.write_database.get_transaction() as connection:
+            result = await connection.fetchrow(user_query, user_id, username, role)
+            if result["result"] == "USER_ID_CONFLICT":
+                raise UserIdConflictException(user_id)
+            if result["result"] == "USERNAME_CONFLICT":
+                raise UsernameConflictException(username)
+            if result["result"] == "UNKNOWN":
+                raise UserCreationException(user_id)
+
+            await connection.execute(profile_query, user_id)
+            await connection.execute(preferences_query, user_id)
+
+    async def delete_user(self, *, user_id: str) -> None:
+        deletion_query = """
+            delete from "user".user_deletions
+            where user_id = $1
+        """
+        user_query = """
+            delete from "user".users
+            where user_id = $1
+        """
+        async with self.write_database.get_transaction() as connection:
+            # Delete from user_deletions first so its AFTER DELETE trigger can insert
+            # into user_change_history while the parent users row still exists.
+            # If users is deleted first, the trigger insert may violate FK to users.
+            await connection.execute(deletion_query, user_id)
+            await connection.execute(user_query, user_id)
+
+    # Login/Authentication
+    async def insert_login_event(self, *, user_id: str, request_context: dict[str, str]) -> None:
+        query = """
+            insert into "user".user_login_events (user_id, request_context)
+            values ($1, $2::jsonb)
+        """
+        json_value = orjson.dumps(request_context).decode()
+        async with self.write_database.get_connection() as connection:
+            try:
+                await connection.execute(query, user_id, json_value)
+            except asyncpg.exceptions.ForeignKeyViolationError:
+                raise DomainUserNotFoundException()
+
+    # User Blocks
+    async def select_blocked_users(self, *, blocker_id: str, created_at: datetime, limit: int) -> list[BlockedUser]:
+        query = """
+            select
+                blocked_id,
+                username,
+                "user".user_blocks.created_at
+            from "user".user_blocks
+            join "user".users on "user".user_blocks.blocked_id = "user".users.user_id
+            where true
+                and "user".user_blocks.blocker_id = $1
+                and "user".user_blocks.created_at <= $2
+            order by "user".user_blocks.created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, blocker_id, created_at, limit)
+            return [
+                BlockedUser(user_id=record["blocked_id"], username=record["username"], created_at=record["created_at"])
+                for record in result
+            ]
+
+    async def insert_user_block(self, *, blocker_id: str, blocked_id: str) -> None:
+        query = """
+            merge into "user".user_blocks 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 matched then
+                do nothing
+            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:
+            try:
+                await connection.execute(query, blocker_id, blocked_id)
+            except asyncpg.exceptions.ForeignKeyViolationError:
+                pass
+            except asyncpg.exceptions.CheckViolationError as exc:
+                if getattr(exc, "constraint_name", None) == "no_self_block":
+                    raise SelfBlockException() from exc
+                raise
+
+    async def delete_user_block(self, *, blocker_id: str, blocked_id: str) -> None:
+        query = """
+            delete from "user".user_blocks
+            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)
+
+    # Preferences
+    async def _select_preferences_with_database(self, *, user_id: str, database: Postgres) -> Preferences:
+        query = """
+            select
+                theme,
+                language
+            from "user".user_preferences
+            where user_id = $1
+        """
+        async with database.get_connection() as connection:
+            result = await connection.fetchrow(query, user_id)
+            if result is None:
+                raise DomainUserNotFoundException()
+            return Preferences(
+                theme=result["theme"],
+                language=result["language"],
+            )
+
+    async def select_preferences(self, *, user_id: str) -> Preferences:
+        return await self._select_preferences_with_database(
+            user_id=user_id,
+            database=self.read_database,
+        )
+
+    async def select_preferences_strong(self, *, user_id: str) -> Preferences:
+        return await self._select_preferences_with_database(
+            user_id=user_id,
+            database=self.strong_read_database,
+        )
+
+    async def update_preferences(self, *, user_id: str, validated_update_request: dict[str, Any]) -> None:
+        if not validated_update_request:
+            return
+
+        ensure_preferences_row_query = """
+            insert into "user".user_preferences (user_id)
+            values ($1)
+            on conflict (user_id) do nothing
+        """
+
+        allowed_fields = {
+            "theme": "theme",
+            "language": "language",
+        }
+
+        set_clauses = []
+        params: list[Any] = [user_id]
+
+        for field, value in validated_update_request.items():
+            if field not in allowed_fields:
+                continue
+            column = allowed_fields[field]
+            params.append(value)
+            set_clauses.append(f"{column} = ${len(params)}")
+
+        if not set_clauses:
+            return
+
+        set_clauses.append("updated_at = now()")
+
+        query = f"""
+            update "user".user_preferences
+            set {", ".join(set_clauses)}
+            where user_id = $1
+        """
+
+        async with self.write_database.get_transaction() as connection:
+            await connection.execute(ensure_preferences_row_query, user_id)
+            await connection.execute(query, *params)
+
+    # Profile
+    async def _select_profile_with_database(self, *, user_id: str, database: Postgres) -> Profile:
+        query = """
+            select
+                display_name,
+                avatar_id,
+                banner_id,
+                bio,
+                status,
+                social_links,
+                profile_visibility::text as profile_visibility
+            from "user".user_profiles
+            where user_id = $1
+        """
+        async with database.get_connection() as connection:
+            result = await connection.fetchrow(query, user_id)
+            if result is None:
+                raise DomainUserNotFoundException()
+            return Profile(
+                display_name=result["display_name"],
+                avatar_id=result["avatar_id"],
+                banner_id=result["banner_id"],
+                bio=result["bio"],
+                status=result["status"],
+                social_links=result["social_links"],
+                profile_visibility=result["profile_visibility"],
+            )
+
+    async def select_profile(self, *, user_id: str) -> Profile:
+        return await self._select_profile_with_database(
+            user_id=user_id,
+            database=self.read_database,
+        )
+
+    async def select_profile_strong(self, *, user_id: str) -> Profile:
+        return await self._select_profile_with_database(
+            user_id=user_id,
+            database=self.strong_read_database,
+        )
+
+    async def update_profile(
+        self,
+        *,
+        user_id: str,
+        validated_update_request: dict[str, Any],
+        actor_id: str | None = None,
+    ) -> None:
+        if not validated_update_request:
+            return
+
+        ensure_profile_row_query = """
+            insert into "user".user_profiles (user_id)
+            values ($1)
+            on conflict (user_id) do nothing
+        """
+
+        # Map of allowed fields to column names
+        allowed_fields = {
+            "display_name": "display_name",
+            "avatar_id": "avatar_id",
+            "banner_id": "banner_id",
+            "bio": "bio",
+            "status": "status",
+            "social_links": "social_links",
+            "profile_visibility": "profile_visibility",
+        }
+
+        set_clauses = []
+        params: list[Any] = [user_id]
+
+        for field, value in validated_update_request.items():
+            if field not in allowed_fields:
+                continue
+            column = allowed_fields[field]
+            params.append(value)
+            set_clauses.append(f"{column} = ${len(params)}")
+
+        if not set_clauses:
+            return
+
+        set_clauses.append("updated_at = now()")
+
+        query = f"""
+            update "user".user_profiles
+            set {", ".join(set_clauses)}
+            where user_id = $1
+        """
+
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(ensure_profile_row_query, user_id)
+            await connection.execute(query, *params)
+
+    async def update_account(
+        self,
+        *,
+        user_id: str,
+        validated_update_request: dict[str, Any],
+        actor_id: str | None = None,
+    ) -> None:
+        if not validated_update_request:
+            return
+
+        allowed_fields = {
+            "username": "username",
+        }
+
+        set_clauses = []
+        params: list[Any] = [user_id]
+
+        for field, value in validated_update_request.items():
+            if field not in allowed_fields:
+                continue
+            column = allowed_fields[field]
+            params.append(value)
+            set_clauses.append(f"{column} = ${len(params)}")
+
+        if not set_clauses:
+            return
+
+        set_clauses.append("updated_at = now()")
+
+        query = f"""
+            update "user".users
+            set {", ".join(set_clauses)}
+            where user_id = $1
+        """
+
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            try:
+                await connection.execute(query, *params)
+            except asyncpg.exceptions.UniqueViolationError as exc:
+                if getattr(exc, "constraint_name", None) == "users_username_key":
+                    raise UsernameConflictException(validated_update_request.get("username", "")) from exc
+                raise
+
+    async def update_user_role(
+        self,
+        *,
+        user_id: str,
+        role: str,
+        actor_id: str | None = None,
+    ) -> None:
+        query = """
+            update "user".users
+            set role = $2::"user".user_role, updated_at = now()
+            where user_id = $1
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id, role)
+
+    # Account Deletion
+    async def insert_user_deletion(
+        self,
+        *,
+        user_id: str,
+        scheduled_for: datetime,
+        actor_id: str | None = None,
+    ) -> None:
+        query = """
+            merge into "user".user_deletions as target
+            using (values ($1, $2::timestamptz)) as source(user_id, scheduled_for)
+            on target.user_id = source.user_id
+            when matched then
+                do nothing
+            when not matched then
+                insert (user_id, scheduled_for)
+                values (source.user_id, source.scheduled_for)
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id, scheduled_for)
+
+    async def delete_user_deletion(self, *, user_id: str, actor_id: str | None = None) -> None:
+        query = """
+            delete from "user".user_deletions
+            where true
+                and user_id = $1
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id)
+
+    async def select_user_for_detail(self, *, user_id: str) -> UserWithProfile | None:
+        query = """
+            select
+                users.user_id,
+                users.username,
+                users.role,
+                users.created_at,
+                user_profiles.display_name,
+                user_profiles.avatar_id,
+                user_profiles.banner_id,
+                user_profiles.bio,
+                user_profiles.status,
+                user_profiles.social_links,
+                user_profiles.profile_visibility::text as profile_visibility,
+                user_deletions.scheduled_for
+            from "user".users
+            inner join "user".user_profiles on users.user_id = user_profiles.user_id
+            left join "user".user_deletions on users.user_id = user_deletions.user_id
+            where users.user_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetchrow(query, user_id)
+            if result is None:
+                return None
+            return UserWithProfile(
+                identity=UserIdentity(
+                    user_id=result["user_id"],
+                    username=result["username"],
+                    display_name=result["display_name"],
+                    role=UserRole(result["role"]),
+                    avatar_id=result["avatar_id"],
+                    created_at=result["created_at"],
+                ),
+                profile=Profile(
+                    display_name=result["display_name"],
+                    avatar_id=result["avatar_id"],
+                    banner_id=result["banner_id"],
+                    bio=result["bio"],
+                    status=result["status"],
+                    social_links=result["social_links"],
+                    profile_visibility=result["profile_visibility"],
+                ),
+                deletion_scheduled_for=result["scheduled_for"],
+            )
+
+    async def select_user_deletion_scheduled_for(self, *, user_id: str) -> datetime | None:
+        query = """
+            select
+                scheduled_for
+            from "user".user_deletions
+            where true
+                and user_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetchrow(query, user_id)
+            return result["scheduled_for"] if result is not None else None
+
+    async def select_expired_user_deletions(self) -> list[str]:
+        query = """
+            select
+                user_id
+            from "user".user_deletions
+            where true
+                and scheduled_for <= now()
+            order by scheduled_for asc
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query)
+            return [record["user_id"] for record in result]
+
+    # User Identity
+    async def _select_user_identity_mapping_with_database(
+        self,
+        *,
+        user_ids: set[str],
+        database: Postgres,
+    ) -> dict[str, UserIdentity]:
+        if not user_ids:
+            return {}
+
+        query = """
+            select
+                users.user_id,
+                users.username,
+                user_profiles.display_name,
+                users.role,
+                user_profiles.avatar_id,
+                users.created_at
+            from "user".users
+            left join "user".user_profiles on users.user_id = user_profiles.user_id
+            where users.user_id = any($1)
+        """
+        async with database.get_connection() as connection:
+            result = await connection.fetch(query, user_ids)
+            return {
+                record["user_id"]: UserIdentity(
+                    user_id=record["user_id"],
+                    username=record["username"],
+                    display_name=record["display_name"],
+                    role=UserRole(record["role"]),
+                    avatar_id=record["avatar_id"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            }
+
+    async def select_user_identity_mapping(self, *, user_ids: set[str]) -> dict[str, UserIdentity]:
+        return await self._select_user_identity_mapping_with_database(
+            user_ids=user_ids,
+            database=self.read_database,
+        )
+
+    async def select_user_identity_mapping_strong(self, *, user_ids: set[str]) -> dict[str, UserIdentity]:
+        return await self._select_user_identity_mapping_with_database(
+            user_ids=user_ids,
+            database=self.strong_read_database,
+        )
+
+    async def select_user_identities(
+        self,
+        *,
+        username: str | None,
+        role: UserRole | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[UserIdentity]:
+        query = """
+            select
+                users.user_id,
+                users.username,
+                user_profiles.display_name,
+                users.role,
+                user_profiles.avatar_id,
+                users.created_at
+            from "user".users
+            left join "user".user_profiles on users.user_id = user_profiles.user_id
+            where true
+                and users.created_at <= $1
+                and ($3::text is null or users.username ilike $3)
+                and ($4::"user".user_role is null or users.role = $4::"user".user_role)
+            order by users.created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            username_filter = f"%{username}%" if username else None
+            result = await connection.fetch(query, cursor, limit, username_filter, role)
+            return [
+                UserIdentity(
+                    user_id=record["user_id"],
+                    username=record["username"],
+                    display_name=record["display_name"],
+                    role=UserRole(record["role"]),
+                    avatar_id=record["avatar_id"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]
+
+    async def select_user_change_history(
+        self,
+        *,
+        user_id: str,
+        cursor: datetime,
+        limit: int,
+    ) -> list[UserChangeHistory]:
+        query = """
+            select
+                user_id,
+                actor_id,
+                entity_type,
+                field,
+                old_value,
+                new_value,
+                created_at
+            from "user".user_change_history
+            where true
+                and user_id = $1
+                and created_at <= $2
+            order by created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, user_id, cursor, limit)
+            return [
+                UserChangeHistory(
+                    user_id=record["user_id"],
+                    actor_id=record["actor_id"],
+                    entity_type=record["entity_type"],
+                    field=record["field"],
+                    old_value=record["old_value"],
+                    new_value=record["new_value"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]