draft: Task/156 add cursor pagination

autotests/clients/rest/models.py

@@ -1,9 +1,7 @@
-from pydantic import BaseModel, NonNegativeInt, PositiveInt
+from pydantic import BaseModel, NaiveDatetime, PositiveInt
 
 
 class PaginatedResponse(BaseModel):
     data: list
-    page: PositiveInt
+    next_cursor: NaiveDatetime | None
     per_page: PositiveInt
-    total_pages: NonNegativeInt | None
-    total_items: NonNegativeInt | None

autotests/clients/rest/projects/client.py

@@ -47,7 +47,7 @@ async def get_projects(
             position_skill_ids: list[uuid.UUID] | Type[Empty] = Empty,
             position_specialization_ids: list[uuid.UUID] | Type[Empty] = Empty,
             participant_user_ids: list[uuid.UUID] | Type[Empty] = Empty,
-            page: int = 1,
+            cursor: datetime | Type[Empty] = Empty,
             per_page: int = 10,
     ) -> ProjectListResponse:
         path = "/api/rest/projects/"
@@ -63,7 +63,7 @@ async def get_projects(
             "position_skill_ids": position_skill_ids,
             "position_specialization_ids": position_specialization_ids,
             "participant_user_ids": participant_user_ids,
-            "page": page,
+            "cursor": cursor,
             "per_page": per_page,
         }
         params = {key: value for key, value in params.items() if value is not Empty}
@@ -146,7 +146,7 @@ async def get_positions(
             project_deadline_ge: datetime | Type[Empty] = Empty,
             project_deadline_le: datetime | Type[Empty] = Empty,
             project_status: ProjectStatusEnum | Type[Empty] = Empty,
-            page: int = 1,
+            cursor: datetime | Type[Empty] = Empty,
             per_page: int = 10,
     ) -> PositionListResponse:
         path = f"/api/rest/positions/"
@@ -161,7 +161,7 @@ async def get_positions(
             "project_deadline_ge": project_deadline_ge,
             "project_deadline_le": project_deadline_le,
             "project_status": Empty if project_status is Empty else project_status.value,
-            "page": page,
+            "cursor": cursor,
             "per_page": per_page,
         }
         params = {key: value for key, value in params.items() if value is not Empty}

sapphire/common/api/dependencies/pagination.py

@@ -1,15 +1,20 @@
+from datetime import datetime
+from typing import Type
+
 from fastapi import Query
 from pydantic import BaseModel, conint
 
+from sapphire.common.utils.empty import Empty
+
 
 class Pagination(BaseModel):
-    page: int
+    cursor: datetime | Type[Empty] = Empty
     per_page: int
 
 
 async def pagination(
-        page: conint(ge=1) = Query(1, description="Page number"),
+        cursor: datetime | None = Query(None, description="Cursor"),
         per_page: conint(ge=1) = Query(10, description="Number of items per page"),
 ) -> Pagination:
 
-    return Pagination(page=page, per_page=per_page)
+    return Pagination(cursor=cursor if cursor else Empty, per_page=per_page)

sapphire/common/api/schemas/paginated.py

@@ -1,11 +1,10 @@
+from datetime import datetime
 from typing import Any
 
 from pydantic import BaseModel
 
 
 class PaginatedResponse(BaseModel):
     data: list[Any]
-    page: int
+    next_cursor: datetime | None
     per_page: int
-    total_pages: int | None = None
-    total_items: int | None = None

sapphire/messenger/api/rest/chats/handlers.py

@@ -23,10 +23,17 @@ async def get_chats(
             session=session,
             user_id=jwt_data.user_id,
             members=filters.member,
+            cursor=pagination.cursor,
+            per_page=pagination.per_page,
         )
 
+    next_cursor = None
+    if db_chats:
+        next_cursor = db_chats[-1].created_at
+
     chats = [ChatResponse.from_db_model(chat) for chat in db_chats]
-    return ChatListResponse(data=chats, page=pagination.page, per_page=pagination.per_page)
+
+    return ChatListResponse(data=chats, next_cursor=next_cursor, per_page=pagination.per_page)
 
 
 async def get_chat(chat: Chat = fastapi.Depends(path_chat_is_member)):

sapphire/messenger/api/rest/chats/messages/handlers.py

@@ -20,10 +20,22 @@ async def get_messages(
     database_service: MessengerDatabaseService = request.app.service.database
 
     async with database_service.transaction() as session:
-        db_messages = await database_service.get_chat_messages(session=session, chat_id=chat.id)
+        db_messages = await database_service.get_chat_messages(
+            session=session,
+            chat_id=chat.id,
+            cursor=pagination.cursor,
+            per_page=pagination.per_page,
+        )
+
+    next_cursor = None
+    if db_messages:
+        next_cursor = db_messages[-1].created_at
 
     messages = [MessageResponse.model_validate(db_message) for db_message in db_messages]
-    return MessageListResponse(data=messages, page=pagination.page, per_page=pagination.per_page)
+
+    return MessageListResponse(
+        data=messages, next_cursor=next_cursor, per_page=pagination.per_page
+    )
 
 
 async def create_message(

sapphire/messenger/database/service.py

@@ -1,8 +1,9 @@
+import datetime
 import pathlib
 import uuid
 from typing import Type
 
-from sqlalchemy import or_, select
+from sqlalchemy import desc, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from sapphire.common.database.service import BaseDatabaseService
@@ -27,13 +28,21 @@ async def get_chats(
             session: AsyncSession,
             user_id: uuid.UUID,
             members: set[uuid.UUID] | Type[Empty] = Empty,
+            cursor: datetime.datetime | Type[Empty] = Empty,
+            per_page: int | Type[Empty] = Empty,
     ) -> list[Chat]:
         query = select(Chat).where(Member.user_id == user_id, Member.chat_id == Chat.id)
 
         filters = []
         if members is not Empty and len(members) > 0:
             filters.append(or_(*(Member.user_id == member for member in members)))
-        query = query.where(*filters)
+
+        if per_page is not Empty:
+            query = query.limit(per_page)
+        if cursor is not Empty:
+            filters.append(Chat.created_at < cursor)
+
+        query = query.where(*filters).order_by(desc(Chat.created_at))
 
         result = await session.execute(query)
 
@@ -61,10 +70,22 @@ async def get_chat(self, session: AsyncSession, chat_id: uuid.UUID) -> Chat | No
 
         return result.unique().scalar_one_or_none()
 
-    async def get_chat_messages(self, session: AsyncSession, chat_id: uuid.UUID) -> list[Message]:
+    async def get_chat_messages(
+            self,
+            session: AsyncSession,
+            chat_id: uuid.UUID,
+            cursor: datetime.datetime | Type[Empty] = Empty,
+            per_page: int | Type[Empty] = Empty,
+    ) -> list[Message]:
         query = (
             select(Message).where(Message.chat_id == chat_id).order_by(Message.created_at.desc())
         )
+
+        if cursor is not Empty:
+            query = query.where(Message.created_at < cursor)
+        if per_page is not Empty:
+            query = query.limit(per_page)
+
         result = await session.execute(query)
 
         return list(result.unique().scalars().all())

sapphire/projects/api/rest/positions/handlers.py

@@ -1,5 +1,3 @@
-import math
-
 import fastapi
 
 from sapphire.common.api.dependencies.pagination import Pagination, pagination
@@ -26,23 +24,21 @@ async def get_positions(
     database_service: ProjectsDatabaseService = request.app.service.database
 
     async with database_service.transaction() as session:
-        positions = await database_service.get_positions(
+        positions_db = await database_service.get_positions(
             session=session,
+            cursor=pagination.cursor,
+            per_page=pagination.per_page,
             **filters.model_dump(),
         )
 
-    total_items = len(positions)
-    total_pages = int(math.ceil(total_items / pagination.per_page))
-    offset = (pagination.page - 1) * pagination.per_page
-    positions = positions[offset:offset + pagination.per_page]
-    data = [PositionResponse.from_db_model(position) for position in positions]
+    next_cursor = None
+    if positions_db:
+        next_cursor = positions_db[-1].created_at
+
+    positions = [PositionResponse.model_validate(position) for position in positions_db]
 
     return PositionListResponse(
-        data=data,
-        total_items=total_items,
-        total_pages=total_pages,
-        page=pagination.page,
-        per_page=pagination.per_page,
+        data=positions, next_cursor=next_cursor, per_page=pagination.per_page
     )
 
 

sapphire/projects/api/rest/projects/handlers.py

@@ -1,4 +1,3 @@
-import math
 import pathlib
 
 import aiofiles
@@ -57,14 +56,20 @@ async def get_projects(
     async with database_service.transaction() as session:
         projects_db = await database_service.get_projects(
             session=session,
-            page=pagination.page,
+            cursor=pagination.cursor,
             per_page=pagination.per_page,
             **filters.model_dump(),
         )
 
+    next_cursor = None
+    if projects_db:
+        next_cursor = projects_db[-1].created_at
+
     projects = [ProjectResponse.model_validate(project_db) for project_db in projects_db]
 
-    return ProjectListResponse(data=projects, page=pagination.page, per_page=pagination.per_page)
+    return ProjectListResponse(
+        data=projects, next_cursor=next_cursor, per_page=pagination.per_page
+    )
 
 
 async def get_project(
@@ -74,22 +79,28 @@ async def get_project(
 
 
 async def history(
+    request: fastapi.Request,
     project: Project = fastapi.Depends(get_path_project),
     pagination: Pagination = fastapi.Depends(pagination),
 ) -> ProjectHistoryListResponse:
-    offset = (pagination.page - 1) * pagination.per_page
-    history = [
-        ProjectHistoryResponse.model_validate(event)
-        for event in project.history[offset : offset + pagination.per_page]
-    ]
-    total_items = len(project.history)
-    total_pages = int(math.ceil(total_items / pagination.per_page))
+    database_service: ProjectsDatabaseService = request.app.service.database
+
+    async with database_service.transaction() as session:
+        project_history_db = await database_service.get_project_history(
+            session=session,
+            project_id=project.id,
+            cursor=pagination.cursor,
+            per_page=pagination.per_page,
+        )
+
+    next_cursor = None
+    if project_history_db:
+        next_cursor = project_history_db[-1].created_at
+
+    history = [ProjectHistoryResponse.model_validate(event) for event in project_history_db]
+
     return ProjectHistoryListResponse(
-        data=history,
-        page=pagination.page,
-        per_page=pagination.per_page,
-        total_pages=total_pages,
-        total_items=total_items,
+        data=history, next_cursor=next_cursor, per_page=pagination.per_page
     )
 
 

sapphire/projects/database/service.py

@@ -148,7 +148,11 @@ async def get_positions(
             project_deadline_ge: datetime | Type[Empty] = Empty,
             project_deadline_le: datetime | Type[Empty] = Empty,
             project_status: ProjectStatusEnum | Type[Empty] = Empty,
+            cursor: datetime | Type[Empty] = Empty,
+            per_page: int | Type[Empty] = Empty,
     ) -> list[Position]:
+        statement = select(Position).order_by(Position.created_at.desc())
+
         filters = []
         skill_filters = []
         project_filters = []
@@ -201,7 +205,12 @@ async def get_positions(
                 Position.project_id.in_(select(Project.id).where(*project_filters))
             )
 
-        statement = select(Position).where(*filters)
+        if cursor is not Empty:
+            filters.append(Position.created_at < cursor)
+        if per_page is not Empty:
+            statement = statement.limit(per_page)
+
+        statement = statement.where(*filters)
         result = await session.execute(statement)
         return list(result.unique().scalars().all())
 
@@ -337,7 +346,7 @@ async def get_projects(
         position_skill_ids: list[uuid.UUID] | Type[Empty] = Empty,
         position_specialization_ids: list[uuid.UUID] | Type[Empty] = Empty,
         participant_user_ids: list[uuid.UUID] | Type[Empty] = Empty,
-        page: int | Type[Empty] = Empty,
+        cursor: datetime | Type[Empty] = Empty,
         per_page: int | Type[Empty] = Empty,
     ) -> list[Project]:
         filters = []
@@ -405,16 +414,38 @@ async def get_projects(
                 Project.id.in_(select(Position.project_id).where(*position_filters))
             )
 
-        query = query.where(*filters)
+        if cursor is not Empty:
+            filters.append(Project.created_at < cursor)
+        if per_page is not Empty:
+            query = query.limit(per_page)
 
-        if page is not Empty and per_page is not Empty:
-            offset = (page - 1) * per_page
-            query = query.limit(per_page).offset(offset)
+        query = query.where(*filters)
 
         result = await session.execute(query)
 
         return list(result.unique().scalars().all())
 
+    async def get_project_history(
+        self,
+        session: AsyncSession,
+        project_id: uuid.UUID,
+        cursor: datetime | Type[Empty] = Empty,
+        per_page: int | Type[Empty] = Empty,
+    ) -> list[Project]:
+        query = (
+            select(ProjectHistory)
+            .where(ProjectHistory.project_id == project_id)
+            .order_by(ProjectHistory.created_at.desc())
+        )
+
+        if cursor is not Empty:
+            query = query.where(ProjectHistory.created_at < cursor)
+        if per_page is not Empty:
+            query = query.limit(per_page)
+
+        result = await session.execute(query)
+        return list(result.unique().scalars().all())
+
     async def get_user_statistic(self, session: AsyncSession, user_id: uuid.UUID) -> UserStatistic:
         stmt = select(
             func.count(Project.id),  # pylint: disable=not-callable