Add experimental graphql endpoint

Author: GianlucaFicarelli

app/application.py

@@ -17,6 +17,7 @@
 from app.db.session import configure_database_session_manager
 from app.dependencies.common import forbid_extra_query_params
 from app.errors import ApiError, ApiErrorCode
+from app.graphql.router import graphql_router
 from app.logger import L
 from app.routers import router
 from app.schemas.api import ErrorResponse
@@ -106,3 +107,4 @@ async def validation_exception_handler(
     },
     dependencies=[Depends(forbid_extra_query_params)],
 )
+app.include_router(graphql_router)

app/graphql/__init__.py

@@ -0,0 +1,7 @@
+from app.graphql.filters import common, species, morphology  # noqa: I001
+
+__all__ = [
+    "common",
+    "morphology",
+    "species",
+]

app/graphql/filters/__init__.py

@@ -0,0 +1,18 @@
+import strawberry
+
+from app.filters.common import AgentFilter, MTypeClassFilter, StrainFilter
+
+
+@strawberry.experimental.pydantic.input(model=MTypeClassFilter, all_fields=True)
+class MTypeClassFilterInput:
+    pass
+
+
+@strawberry.experimental.pydantic.input(model=StrainFilter, all_fields=True)
+class StrainFilterInput:
+    pass
+
+
+@strawberry.experimental.pydantic.input(model=AgentFilter, all_fields=True)
+class AgentFilterInput:
+    pass

app/graphql/filters/common.py

@@ -0,0 +1,8 @@
+import strawberry
+
+from app.filters.morphology import MorphologyFilter
+
+
+@strawberry.experimental.pydantic.input(model=MorphologyFilter, all_fields=True)
+class MorphologyFilterInput:
+    pass

app/graphql/filters/morphology.py

@@ -0,0 +1,8 @@
+import strawberry
+
+from app.filters.common import SpeciesFilter
+
+
+@strawberry.experimental.pydantic.input(model=SpeciesFilter, all_fields=True)
+class SpeciesFilterInput:
+    pass

app/graphql/filters/species.py

@@ -0,0 +1,74 @@
+import uuid
+from typing import TYPE_CHECKING
+
+import strawberry
+
+import app.service.morphology
+from app.dependencies.auth import user_with_project_id
+from app.filters.morphology import MorphologyFilter
+from app.graphql.filters.morphology import MorphologyFilterInput
+from app.graphql.types.morphology import MorphologyInput, MorphologyType
+from app.graphql.types.pagination import ListResponseType, PaginationRequestInput
+from app.schemas.morphology import ReconstructionMorphologyCreate, ReconstructionMorphologyRead
+from app.schemas.types import PaginationRequest
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+    from app.schemas.auth import UserContext, UserContextWithProjectId
+
+
+@strawberry.type
+class MorphologyQuery:
+    @strawberry.field
+    def read_many_morphologies(
+        self,
+        *,
+        info: strawberry.Info,
+        pagination_request: PaginationRequestInput,
+        morphology_filter: MorphologyFilterInput,
+        search: str | None = None,
+        with_facets: bool = False,
+    ) -> ListResponseType[MorphologyType, ReconstructionMorphologyRead]:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        user_context: UserContext = info.context.user_context
+        validated_pagination_request = PaginationRequest.model_validate(
+            pagination_request, from_attributes=True
+        )
+        validated_morphology_filter = MorphologyFilter.model_validate(
+            morphology_filter, from_attributes=True
+        )
+        result = app.service.morphology.read_many(
+            user_context=user_context,
+            db=db,
+            pagination_request=validated_pagination_request,
+            morphology_filter=validated_morphology_filter,
+            search=search,
+            with_facets=with_facets,
+        )
+        return ListResponseType[MorphologyType, ReconstructionMorphologyRead].from_pydantic(result)
+
+    @strawberry.field
+    def read_morphology(self, id_: uuid.UUID, info: strawberry.Info) -> MorphologyType | None:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        user_context: UserContext = info.context.user_context
+        result = app.service.morphology.read_one(user_context=user_context, db=db, id_=id_)
+        return MorphologyType.from_pydantic(result) if result else None
+
+
+@strawberry.type
+class MorphologyMutation:
+    @strawberry.mutation
+    def create_morphology(
+        self, morphology: MorphologyInput, info: strawberry.Info
+    ) -> MorphologyType:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        user_context: UserContextWithProjectId = user_with_project_id(info.context.user_context)
+        validated = ReconstructionMorphologyCreate.model_validate(morphology)
+        result = app.service.morphology.create(
+            user_context=user_context, db=db, reconstruction=validated
+        )
+        return MorphologyType.from_pydantic(result)

app/graphql/resolvers/__init__.py

@@ -0,0 +1,59 @@
+import uuid
+from typing import TYPE_CHECKING
+
+import strawberry
+
+import app.service.species
+from app.filters.common import SpeciesFilter
+from app.graphql.filters.species import SpeciesFilterInput
+from app.graphql.types.common import SpeciesInput, SpeciesType
+from app.graphql.types.pagination import ListResponseType, PaginationRequestInput
+from app.schemas.base import SpeciesCreate, SpeciesRead
+from app.schemas.types import PaginationRequest
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+
+@strawberry.type
+class SpeciesQuery:
+    @strawberry.field
+    def read_many_species(
+        self,
+        *,
+        pagination_request: PaginationRequestInput,
+        species_filter: SpeciesFilterInput,
+        info: strawberry.Info,
+    ) -> ListResponseType[SpeciesType, SpeciesRead]:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        validated_pagination_request = PaginationRequest.model_validate(
+            pagination_request, from_attributes=True
+        )
+        validated_species_filter = SpeciesFilter.model_validate(
+            species_filter, from_attributes=True
+        )
+        result = app.service.species.read_many(
+            db=db,
+            pagination_request=validated_pagination_request,
+            species_filter=validated_species_filter,
+        )
+        return ListResponseType[SpeciesType, SpeciesRead].from_pydantic(result)
+
+    @strawberry.field
+    def read_species(self, *, id_: uuid.UUID, info: strawberry.Info) -> SpeciesType | None:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        result = app.service.species.read_one(db=db, id_=id_)
+        return SpeciesType.from_pydantic(result) if result else None
+
+
+@strawberry.type
+class SpeciesMutation:
+    @strawberry.mutation
+    def create_species(self, *, species: SpeciesInput, info: strawberry.Info) -> SpeciesType:
+        # for proper validation, validate the input and return a pydantic model
+        db: Session = info.context.db
+        validated = SpeciesCreate.model_validate(species)
+        result = app.service.species.create(db=db, species=validated)
+        return SpeciesType.from_pydantic(result)

app/graphql/resolvers/morphology.py

@@ -0,0 +1,30 @@
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from strawberry.fastapi import BaseContext, GraphQLRouter
+
+from app.dependencies.auth import UserContextDep, user_with_service_admin_role
+from app.dependencies.db import SessionDep
+from app.graphql.schema import schema
+from app.schemas.auth import UserContext
+
+
+class Context(BaseContext):
+    def __init__(self, *, db: Session, user_context: UserContext) -> None:
+        """Initialize a new Context."""
+        super().__init__()
+        self.db = db
+        self.user_context = user_context
+
+
+def get_context(db: SessionDep, user_context: UserContextDep) -> Context:
+    return Context(db=db, user_context=user_context)
+
+
+graphql_router = GraphQLRouter(
+    schema,
+    prefix="/graphql",
+    graphql_ide="apollo-sandbox",
+    context_getter=get_context,
+    dependencies=[Depends(user_with_service_admin_role)],
+    include_in_schema=False,
+)