fastapi-sdk 0.4.2__tar.gz → 0.4.4__tar.gz

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-sdk
-Version: 0.4.2
+Version: 0.4.4
 Summary: Utilities for FastAPI projects.
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/fastapi_sdk/controllers/model.py

@@ -242,12 +242,21 @@ class ModelController:
         query: Optional[List[dict]] = None,
         order_by: Optional[dict] = None,
         claims: Optional[Dict[str, Any]] = None,
+        include: Optional[List[str]] = None,
     ) -> List[BaseModel]:
-        """List models."""
+        """List models.
+
+        Args:
+            page: The page number (0-based)
+            query: Optional query filters
+            order_by: Optional sorting criteria
+            claims: Optional claims for ownership verification
+            include: Optional list of related objects to include
+        """
         # Get the collection
-        collection_name = self.model.model_config[
-            "collection"
-        ] or self.model.__name__.lower().replace("model", "")
+        collection_name = (
+            self.model.model_config.get("collection") or self.model.__collection__
+        )
         _collection = self.db_engine.database[collection_name]
 
         # Create a pipeline for aggregation
@@ -268,10 +277,53 @@ class ModelController:
                 )
             if claims:
                 ownership_filter = self._get_ownership_filter(claims)
-                print("ownership_filter", ownership_filter)
                 if ownership_filter:
                     _query.update(ownership_filter)
 
+        # Append pipeline stages for related objects
+        if include:
+            for relation in include:
+                if relation not in self.relationships:
+                    continue
+
+                rel_info = self.relationships[relation]
+                rel_controller_name = rel_info["controller"]
+                rel_type = rel_info["type"]
+                foreign_key = rel_info.get("foreign_key")
+
+                # Get the controller class from the registry
+                rel_controller_class = self.get_controller(rel_controller_name)
+
+                if rel_type == "one_to_many":
+                    _pipeline.append(
+                        {
+                            "$lookup": {
+                                "from": rel_controller_class.model.model_config.get(
+                                    "collection"
+                                )
+                                or rel_controller_class.model.__collection__,
+                                "localField": "uuid",
+                                "foreignField": foreign_key,
+                                "as": relation,
+                            }
+                        }
+                    )
+                elif rel_type == "many_to_one":
+                    _pipeline.append(
+                        {
+                            "$lookup": {
+                                "from": rel_controller_class.model.model_config.get(
+                                    "collection"
+                                )
+                                or rel_controller_class.model.__collection__,
+                                "localField": foreign_key,
+                                "foreignField": "uuid",
+                                "as": relation,
+                            }
+                        }
+                    )
+                    _pipeline.append({"$unwind": f"${relation}"})
+
         # Sorting, default by created_at
         _sort = order_by if order_by else {"created_at": -1}
 
@@ -293,12 +345,15 @@ class ModelController:
         if total % self.n_per_page > 0:
             pages += 1
 
+        # Convert items to models
+        models = [self.model.model_validate_doc(item) for item in items]
+
         return {
-            "items": [self.model.model_validate_doc(item) for item in items],
+            "items": models,
             "total": total,
             "page": page,
             "pages": pages,
-            "size": len(items),
+            "size": len(models),
         }
 
     async def list_related(

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/fastapi_sdk/controllers/route.py

@@ -6,7 +6,7 @@ with database and user dependencies.
 
 from typing import Any, Callable, List, Optional, Type
 
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from pydantic import BaseModel
 
 from fastapi_sdk.controllers import ModelController
@@ -112,13 +112,38 @@ class RouteController:
         async def get_route(
             request: Request,
             resource_id: str,
+            include: List[str] = Query(default=None),
             db: Any = Depends(self.get_db),
         ):
-            """Get a resource by ID (requires authentication)."""
-            instance = await self.controller(db).get(
-                uuid=resource_id,
-                claims=request.state.claims,
-            )
+            """Get a resource by ID (requires authentication).
+
+            Args:
+                request: The FastAPI request object
+                resource_id: The ID of the resource to get
+                include: Optional list of related objects to include in the response
+                db: The database connection
+
+            Example:
+                # Get an account with its projects included
+                GET /accounts/{account_id}?include=projects
+
+                # Get a project with its tasks included
+                GET /projects/{project_id}?include=tasks
+
+                # Get an account with multiple relations included
+                GET /accounts/{account_id}?include=projects&include=tasks
+            """
+            if include:
+                instance = await self.controller(db).get_with_relations(
+                    uuid=resource_id,
+                    include=include,
+                    claims=request.state.claims,
+                )
+            else:
+                instance = await self.controller(db).get(
+                    uuid=resource_id,
+                    claims=request.state.claims,
+                )
             if not instance:
                 raise HTTPException(status_code=404, detail="Resource not found")
             return self.schema_response(**instance.model_dump())
@@ -130,11 +155,30 @@ class RouteController:
         @require_permission(f"{self.model_name}:read")
         async def list_route(
             request: Request,
+            include: List[str] = Query(default=None),
             db: Any = Depends(self.get_db),
         ):
-            """List all resources (requires authentication)."""
+            """List all resources (requires authentication).
+
+            Args:
+                request: The FastAPI request object
+                db: The database connection
+                include: Optional list of related objects to include in the response
+
+            Example:
+                # List accounts with their projects included
+                GET /accounts/?include=projects
+
+                # List projects with their tasks included
+                GET /projects/?include=tasks
+
+                # List accounts with multiple relations included
+                GET /accounts/?include=projects&include=tasks
+            """
+
             instances = await self.controller(db).list(
                 claims=request.state.claims,
+                include=include,
             )
             return instances
 

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/fastapi_sdk/security/oauth.py

@@ -77,11 +77,8 @@ def decode_access_token(
 
         # Validate expiration and other standard claims
         claims.validate()
-        print("claims", claims)
 
         # Check if issuer matches auth_issuer
-        print("claims.get('iss')", claims.get("iss"))
-        print("auth_issuer", auth_issuer)
         if claims.get("iss") != auth_issuer:
             logger.error("Token issuer does not match auth_issuer")
             raise ValueError("Token issuer does not match auth_issuer")

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/fastapi_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-sdk
-Version: 0.4.2
+Version: 0.4.4
 Summary: Utilities for FastAPI projects.
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-sdk"
-version = "0.4.2"
+version = "0.4.4"
 description = "Utilities for FastAPI projects."
 readme = "README.md"
 requires-python = ">=3.13"

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/tests/test_controller_model.py

@@ -542,3 +542,69 @@ class TestOwnership:
         # Delete the record without claims
         deleted = await controller.delete(instance.uuid, claims=None)
         assert deleted.deleted is True
+
+
+@pytest.mark.asyncio
+async def test_list_with_relations(db_engine: AgnosticDatabase):
+    """Test listing models with included relations."""
+
+    # Create test data
+    account = await Account(db_engine).create({"name": "Test Account"})
+    account_claims = {"account_id": account.uuid}
+    project = await Project(db_engine).create(
+        {"name": "Test Project", "account_id": account.uuid},
+        claims=account_claims,
+    )
+    task = await Task(db_engine).create(
+        {
+            "name": "Test Task",
+            "description": "Test Task Description",
+            "account_id": account.uuid,
+            "project_id": project.uuid,
+        },
+        claims=account_claims,
+    )
+
+    # Test listing accounts with projects included
+    result = await Account(db_engine).list(include=["projects"], claims=account_claims)
+    assert result["total"] >= 1
+    account_with_projects = next(
+        (a for a in result["items"] if a.uuid == account.uuid), None
+    )
+    assert account_with_projects is not None
+    assert hasattr(account_with_projects, "projects")
+    assert len(account_with_projects.projects) >= 1
+    assert any(p.uuid == project.uuid for p in account_with_projects.projects)
+
+    # Test listing projects with tasks included
+    result = await Project(db_engine).list(include=["tasks"], claims=account_claims)
+    assert result["total"] >= 1
+    project_with_tasks = next(
+        (p for p in result["items"] if p.uuid == project.uuid), None
+    )
+    assert project_with_tasks is not None
+    assert hasattr(project_with_tasks, "tasks")
+    assert len(project_with_tasks.tasks) >= 1
+    assert any(t.uuid == task.uuid for t in project_with_tasks.tasks)
+
+    # Test listing with multiple relations
+    result = await Project(db_engine).list(
+        include=["tasks", "account"], claims=account_claims
+    )
+    assert result["total"] >= 1
+    project_with_relations = next(
+        (p for p in result["items"] if p.uuid == project.uuid), None
+    )
+    assert project_with_relations is not None
+    assert hasattr(project_with_relations, "account")
+    assert hasattr(project_with_relations, "tasks")
+    assert len(project_with_relations.tasks) >= 1
+    assert any(t.uuid == task.uuid for t in project_with_relations.tasks)
+
+    # Test listing with non-existent relation
+    result = await Account(db_engine).list(
+        include=["non_existent"], claims=account_claims
+    )
+    assert result["total"] >= 1
+    account = next((a for a in result["items"] if a.uuid == account.uuid), None)
+    assert account is not None

{fastapi_sdk-0.4.2 → fastapi_sdk-0.4.4}/tests/test_controller_route.py

@@ -162,6 +162,44 @@ class TestTaskRoutes:
         assert data["uuid"] == task.uuid
         assert data["description"] == task.description
 
+    async def test_get_with_relations(
+        self, client, auth_headers, account, project, task
+    ):
+        """Test getting a resource with included relations."""
+        # Test getting an account with projects included
+        response = client.get(
+            f"/accounts/{account.uuid}?include=projects", headers=auth_headers
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["uuid"] == account.uuid
+        assert "projects" in data
+        assert len(data["projects"]) >= 1
+        assert any(p["uuid"] == project.uuid for p in data["projects"])
+
+        # Test getting a project with tasks and account included
+        response = client.get(
+            f"/projects/{project.uuid}?include=tasks&include=account",
+            headers=auth_headers,
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["uuid"] == project.uuid
+        assert "tasks" in data
+        assert len(data["tasks"]) >= 1
+        assert any(t["uuid"] == task.uuid for t in data["tasks"])
+        assert "account" in data
+        assert data["account"]["uuid"] == account.uuid
+
+        # Test with non-existent relation
+        response = client.get(
+            f"/accounts/{account.uuid}?include=non_existent", headers=auth_headers
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["uuid"] == account.uuid
+        assert "non_existent" not in data
+
     async def test_list_tasks(self, client, auth_headers, task):
         """Test listing tasks."""
         response = client.get("/tasks/", headers=auth_headers)
@@ -170,6 +208,51 @@ class TestTaskRoutes:
         assert len(data["items"]) >= 1
         assert any(t["uuid"] == task.uuid for t in data["items"])
 
+    async def test_list_with_relations(
+        self, client, auth_headers, account, project, task
+    ):
+        """Test listing resources with included relations."""
+        # Test listing accounts with projects included
+        response = client.get("/accounts/?include=projects", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["items"]) >= 1
+        account_data = next(a for a in data["items"] if a["uuid"] == account.uuid)
+        assert "projects" in account_data
+        assert len(account_data["projects"]) >= 1
+        assert any(p["uuid"] == project.uuid for p in account_data["projects"])
+
+        # Test listing projects with tasks included
+        response = client.get(
+            "/projects/?include=tasks&include=account", headers=auth_headers
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["items"]) >= 1
+        project_data = next(p for p in data["items"] if p["uuid"] == project.uuid)
+        assert "tasks" in project_data
+        assert len(project_data["tasks"]) >= 1
+        assert any(t["uuid"] == task.uuid for t in project_data["tasks"])
+        assert "account" in project_data
+        assert project_data["account"]["uuid"] == account.uuid
+
+        # Test listing tasks with multiple relations included
+        response = client.get("/tasks/?include=project", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["items"]) >= 1
+        task_data = next(t for t in data["items"] if t["uuid"] == task.uuid)
+        assert "project" in task_data
+        assert task_data["project"]["uuid"] == project.uuid
+
+        # Test with non-existent relation
+        response = client.get("/accounts/?include=non_existent", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["items"]) >= 1
+        account_data = next(a for a in data["items"] if a["uuid"] == account.uuid)
+        assert "non_existent" not in account_data
+
     async def test_update_task(self, client, auth_headers, task):
         """Test updating a task."""
         response = client.put(
@@ -177,7 +260,6 @@ class TestTaskRoutes:
             headers=auth_headers,
             json={"description": "Updated description"},
         )
-        print(response.json())
         assert response.status_code == 200
         data = response.json()
         assert data["description"] == "Updated description"