unification of api (result -> skip/has more,..)

Author: HardMax71

backend/app/api/routes/events.py

@@ -38,20 +38,30 @@ async def get_execution_events(
     current_user: Annotated[UserResponse, Depends(current_user)],
     event_service: FromDishka[EventService],
     include_system_events: bool = Query(False, description="Include system-generated events"),
+    limit: int = Query(100, ge=1, le=1000),
+    skip: int = Query(0, ge=0),
 ) -> EventListResponse:
-    events = await event_service.get_execution_events(
+    result = await event_service.get_execution_events(
         execution_id=execution_id,
         user_id=current_user.user_id,
         user_role=current_user.role,
         include_system_events=include_system_events,
+        limit=limit,
+        skip=skip,
     )
 
-    if events is None:
+    if result is None:
         raise HTTPException(status_code=403, detail="Access denied")
 
-    event_responses = [EventResponse.model_validate(event) for event in events]
+    event_responses = [EventResponse.model_validate(event) for event in result.events]
 
-    return EventListResponse(events=event_responses, total=len(event_responses), limit=1000, skip=0, has_more=False)
+    return EventListResponse(
+        events=event_responses,
+        total=result.total,
+        limit=limit,
+        skip=skip,
+        has_more=result.has_more,
+    )
 
 
 @router.get("/user", response_model=EventListResponse)
@@ -126,41 +136,57 @@ async def get_events_by_correlation(
     event_service: FromDishka[EventService],
     include_all_users: bool = Query(False, description="Include events from all users (admin only)"),
     limit: int = Query(100, ge=1, le=1000),
+    skip: int = Query(0, ge=0),
 ) -> EventListResponse:
-    events = await event_service.get_events_by_correlation(
+    result = await event_service.get_events_by_correlation(
         correlation_id=correlation_id,
         user_id=current_user.user_id,
         user_role=current_user.role,
         include_all_users=include_all_users,
         limit=limit,
+        skip=skip,
     )
 
-    event_responses = [EventResponse.model_validate(event) for event in events]
+    event_responses = [EventResponse.model_validate(event) for event in result.events]
 
-    return EventListResponse(events=event_responses, total=len(event_responses), limit=limit, skip=0, has_more=False)
+    return EventListResponse(
+        events=event_responses,
+        total=result.total,
+        limit=limit,
+        skip=skip,
+        has_more=result.has_more,
+    )
 
 
 @router.get("/current-request", response_model=EventListResponse)
 async def get_current_request_events(
     current_user: Annotated[UserResponse, Depends(current_user)],
     event_service: FromDishka[EventService],
     limit: int = Query(100, ge=1, le=1000),
+    skip: int = Query(0, ge=0),
 ) -> EventListResponse:
     correlation_id = CorrelationContext.get_correlation_id()
     if not correlation_id:
-        return EventListResponse(events=[], total=0, limit=limit, skip=0, has_more=False)
+        return EventListResponse(events=[], total=0, limit=limit, skip=skip, has_more=False)
 
-    events = await event_service.get_events_by_correlation(
+    result = await event_service.get_events_by_correlation(
         correlation_id=correlation_id,
         user_id=current_user.user_id,
         user_role=current_user.role,
         include_all_users=False,
         limit=limit,
+        skip=skip,
     )
 
-    event_responses = [EventResponse.model_validate(event) for event in events]
+    event_responses = [EventResponse.model_validate(event) for event in result.events]
 
-    return EventListResponse(events=event_responses, total=len(event_responses), limit=limit, skip=0, has_more=False)
+    return EventListResponse(
+        events=event_responses,
+        total=result.total,
+        limit=limit,
+        skip=skip,
+        has_more=result.has_more,
+    )
 
 
 @router.get("/statistics", response_model=EventStatistics)

backend/app/api/routes/saga.py

@@ -56,6 +56,8 @@ async def get_execution_sagas(
     saga_service: FromDishka[SagaService],
     auth_service: FromDishka[AuthService],
     state: SagaState | None = Query(None, description="Filter by saga state"),
+    limit: int = Query(100, ge=1, le=1000),
+    skip: int = Query(0, ge=0),
 ) -> SagaListResponse:
     """Get all sagas for an execution.
 
@@ -65,9 +67,11 @@ async def get_execution_sagas(
         saga_service: Saga service from DI
         auth_service: Auth service from DI
         state: Optional state filter
+        limit: Maximum number of results
+        skip: Number of results to skip
 
     Returns:
-        List of sagas for the execution
+        Paginated list of sagas for the execution
 
     Raises:
         HTTPException: 403 if access denied
@@ -76,9 +80,15 @@ async def get_execution_sagas(
 
     service_user = User.from_response(current_user)
     domain_user = AdminUserMapper.from_pydantic_service_user(service_user)
-    sagas = await saga_service.get_execution_sagas(execution_id, domain_user, state)
-    saga_responses = [SagaStatusResponse.from_domain(s) for s in sagas]
-    return SagaListResponse(sagas=saga_responses, total=len(saga_responses))
+    result = await saga_service.get_execution_sagas(execution_id, domain_user, state, limit=limit, skip=skip)
+    saga_responses = [SagaStatusResponse.from_domain(s) for s in result.sagas]
+    return SagaListResponse(
+        sagas=saga_responses,
+        total=result.total,
+        skip=skip,
+        limit=limit,
+        has_more=result.has_more,
+    )
 
 
 @router.get("/", response_model=SagaListResponse)
@@ -88,7 +98,7 @@ async def list_sagas(
     auth_service: FromDishka[AuthService],
     state: SagaState | None = Query(None, description="Filter by saga state"),
     limit: int = Query(100, ge=1, le=1000),
-    offset: int = Query(0, ge=0),
+    skip: int = Query(0, ge=0),
 ) -> SagaListResponse:
     """List sagas accessible by the current user.
 
@@ -98,7 +108,7 @@ async def list_sagas(
         auth_service: Auth service from DI
         state: Optional state filter
         limit: Maximum number of results
-        offset: Number of results to skip
+        skip: Number of results to skip
 
     Returns:
         Paginated list of sagas
@@ -107,9 +117,15 @@ async def list_sagas(
 
     service_user = User.from_response(current_user)
     domain_user = AdminUserMapper.from_pydantic_service_user(service_user)
-    result = await saga_service.list_user_sagas(domain_user, state, limit, offset)
+    result = await saga_service.list_user_sagas(domain_user, state, limit, skip)
     saga_responses = [SagaStatusResponse.from_domain(s) for s in result.sagas]
-    return SagaListResponse(sagas=saga_responses, total=result.total)
+    return SagaListResponse(
+        sagas=saga_responses,
+        total=result.total,
+        skip=skip,
+        limit=limit,
+        has_more=result.has_more,
+    )
 
 
 @router.post("/{saga_id}/cancel", response_model=SagaCancellationResponse)

backend/app/api/routes/user_settings.py

@@ -100,7 +100,7 @@ async def get_settings_history(
 ) -> SettingsHistoryResponse:
     history = await settings_service.get_settings_history(current_user.user_id, limit=limit)
     entries = [SettingsHistoryEntry.model_validate(entry) for entry in history]
-    return SettingsHistoryResponse(history=entries, total=len(entries))
+    return SettingsHistoryResponse(history=entries, limit=limit)
 
 
 @router.post("/restore", response_model=UserSettings)

backend/app/db/repositories/event_repository.py

@@ -125,14 +125,26 @@ async def get_events_by_aggregate(
         docs = await cursor.to_list(length=limit)
         return [self.mapper.from_mongo_document(doc) for doc in docs]
 
-    async def get_events_by_correlation(self, correlation_id: str, limit: int = 100) -> list[Event]:
+    async def get_events_by_correlation(
+        self, correlation_id: str, limit: int = 100, skip: int = 0
+    ) -> EventListResult:
+        query = {EventFields.METADATA_CORRELATION_ID: correlation_id}
+        total_count = await self._collection.count_documents(query)
+
         cursor = (
-            self._collection.find({EventFields.METADATA_CORRELATION_ID: correlation_id})
+            self._collection.find(query)
             .sort(EventFields.TIMESTAMP, ASCENDING)
+            .skip(skip)
             .limit(limit)
         )
         docs = await cursor.to_list(length=limit)
-        return [self.mapper.from_mongo_document(doc) for doc in docs]
+        return EventListResult(
+            events=[self.mapper.from_mongo_document(doc) for doc in docs],
+            total=total_count,
+            skip=skip,
+            limit=limit,
+            has_more=(skip + limit) < total_count,
+        )
 
     async def get_events_by_user(
         self,
@@ -154,12 +166,26 @@ async def get_events_by_user(
         docs = await cursor.to_list(length=limit)
         return [self.mapper.from_mongo_document(doc) for doc in docs]
 
-    async def get_execution_events(self, execution_id: str, limit: int = 100) -> list[Event]:
+    async def get_execution_events(
+        self, execution_id: str, limit: int = 100, skip: int = 0
+    ) -> EventListResult:
         query = {"$or": [{EventFields.PAYLOAD_EXECUTION_ID: execution_id}, {EventFields.AGGREGATE_ID: execution_id}]}
+        total_count = await self._collection.count_documents(query)
 
-        cursor = self._collection.find(query).sort(EventFields.TIMESTAMP, ASCENDING).limit(limit)
+        cursor = (
+            self._collection.find(query)
+            .sort(EventFields.TIMESTAMP, ASCENDING)
+            .skip(skip)
+            .limit(limit)
+        )
         docs = await cursor.to_list(length=limit)
-        return [self.mapper.from_mongo_document(doc) for doc in docs]
+        return EventListResult(
+            events=[self.mapper.from_mongo_document(doc) for doc in docs],
+            total=total_count,
+            skip=skip,
+            limit=limit,
+            has_more=(skip + limit) < total_count,
+        )
 
     async def search_events(
         self, text_query: str, filters: dict[str, object] | None = None, limit: int = 100, skip: int = 0

backend/app/db/repositories/saga_repository.py

@@ -46,14 +46,19 @@ async def get_saga(self, saga_id: str) -> Saga | None:
         doc = await self.sagas.find_one({"saga_id": saga_id})
         return self.mapper.from_mongo(doc) if doc else None
 
-    async def get_sagas_by_execution(self, execution_id: str, state: SagaState | None = None) -> list[Saga]:
+    async def get_sagas_by_execution(
+        self, execution_id: str, state: SagaState | None = None, limit: int = 100, skip: int = 0
+    ) -> SagaListResult:
         query: dict[str, object] = {"execution_id": execution_id}
         if state:
             query["state"] = state.value
 
-        cursor = self.sagas.find(query).sort("created_at", DESCENDING)
-        docs = await cursor.to_list(length=None)
-        return [self.mapper.from_mongo(doc) for doc in docs]
+        total = await self.sagas.count_documents(query)
+        cursor = self.sagas.find(query).sort("created_at", DESCENDING).skip(skip).limit(limit)
+        docs = await cursor.to_list(length=limit)
+        sagas = [self.mapper.from_mongo(doc) for doc in docs]
+
+        return SagaListResult(sagas=sagas, total=total, skip=skip, limit=limit)
 
     async def list_sagas(self, saga_filter: SagaFilter, limit: int = 100, skip: int = 0) -> SagaListResult:
         query = self.filter_mapper.to_mongodb_query(saga_filter)

backend/app/schemas_pydantic/saga.py

@@ -44,6 +44,9 @@ class SagaListResponse(BaseModel):
 
     sagas: list[SagaStatusResponse]
     total: int
+    skip: int
+    limit: int
+    has_more: bool
 
 
 class SagaCancellationResponse(BaseModel):

backend/app/schemas_pydantic/user_settings.py

@@ -110,12 +110,12 @@ class SettingsHistoryEntry(BaseModel):
 
 
 class SettingsHistoryResponse(BaseModel):
-    """Response model for settings history"""
+    """Response model for settings history (limited snapshot of recent changes)"""
 
     model_config = ConfigDict(from_attributes=True)
 
     history: List[SettingsHistoryEntry]
-    total: int
+    limit: int
 
 
 class RestoreSettingsRequest(BaseModel):

backend/app/services/event_service.py

@@ -34,13 +34,17 @@ async def get_execution_events(
         user_id: str,
         user_role: UserRole,
         include_system_events: bool = False,
-    ) -> list[Event] | None:
-        events = await self.repository.get_events_by_aggregate(aggregate_id=execution_id, limit=1000)
-        if not events:
-            return []
+        limit: int = 1000,
+        skip: int = 0,
+    ) -> EventListResult | None:
+        result = await self.repository.get_execution_events(
+            execution_id=execution_id, limit=limit, skip=skip
+        )
+        if not result.events:
+            return EventListResult(events=[], total=0, skip=skip, limit=limit, has_more=False)
 
         owner = None
-        for e in events:
+        for e in result.events:
             if e.metadata and e.metadata.user_id:
                 owner = e.metadata.user_id
                 break
@@ -49,9 +53,17 @@ async def get_execution_events(
             return None
 
         if not include_system_events:
-            events = [e for e in events if not (e.metadata and e.metadata.service_name.startswith("system-"))]
-
-        return events
+            filtered = [e for e in result.events if not (e.metadata and e.metadata.service_name.startswith("system-"))]
+            # Recalculate has_more based on filtered count
+            return EventListResult(
+                events=filtered,
+                total=result.total,
+                skip=skip,
+                limit=limit,
+                has_more=result.has_more,
+            )
+
+        return result
 
     async def get_user_events_paginated(
         self,
@@ -118,11 +130,21 @@ async def get_events_by_correlation(
         user_role: UserRole,
         include_all_users: bool = False,
         limit: int = 100,
-    ) -> list[Event]:
-        events = await self.repository.get_events_by_correlation(correlation_id=correlation_id, limit=limit)
+        skip: int = 0,
+    ) -> EventListResult:
+        result = await self.repository.get_events_by_correlation(
+            correlation_id=correlation_id, limit=limit, skip=skip
+        )
         if not include_all_users or user_role != UserRole.ADMIN:
-            events = [e for e in events if (e.metadata and e.metadata.user_id == user_id)]
-        return events
+            filtered = [e for e in result.events if (e.metadata and e.metadata.user_id == user_id)]
+            return EventListResult(
+                events=filtered,
+                total=result.total,
+                skip=skip,
+                limit=limit,
+                has_more=result.has_more,
+            )
+        return result
 
     async def get_event_statistics(
         self,

backend/app/services/saga/saga_service.py

@@ -63,7 +63,9 @@ async def get_saga_with_access_check(self, saga_id: str, user: User) -> Saga:
 
         return saga
 
-    async def get_execution_sagas(self, execution_id: str, user: User, state: SagaState | None = None) -> list[Saga]:
+    async def get_execution_sagas(
+        self, execution_id: str, user: User, state: SagaState | None = None, limit: int = 100, skip: int = 0
+    ) -> SagaListResult:
         """Get sagas for an execution with access control."""
         # Check access to execution
         if not await self.check_execution_access(execution_id, user):
@@ -72,7 +74,7 @@ async def get_execution_sagas(self, execution_id: str, user: User, state: SagaSt
             )
             raise SagaAccessDeniedError(f"Access denied - no access to execution {execution_id}")
 
-        return await self.saga_repo.get_sagas_by_execution(execution_id, state)
+        return await self.saga_repo.get_sagas_by_execution(execution_id, state, limit=limit, skip=skip)
 
     async def list_user_sagas(
         self, user: User, state: SagaState | None = None, limit: int = 100, skip: int = 0

backend/tests/unit/infrastructure/mappers/test_infra_event_mapper.py

@@ -57,7 +57,9 @@ def test_archived_export_mapper() -> None:
     arch = ArchivedEventMapper.from_event(e, deleted_by="admin", deletion_reason="r")
     assert arch.deleted_by == "admin"
     arch_doc = ArchivedEventMapper.to_mongo_document(arch)
-    assert "_deleted_at" in arch_doc or "_deletion_reason" in arch_doc or True  # enum names vary
+    assert "_deleted_at" in arch_doc
+    assert "_deleted_by" in arch_doc
+    assert "_deletion_reason" in arch_doc
 
     row = type("Row", (), {})()
     row.event_id = e.event_id