Dependencies on API Routers not being called for routes via add_route

[navyamehta]

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from fastapi import APIRouter, Depends, HTTPException
from strawberry.asgi import GraphQL
from . import graphql_schema

def some_func():
	print("CALLED")
	raise HTTPException(status_code=400, detail="X-Token header invalid")

print("HERE")

router = APIRouter(dependencies=[Depends(some_func)])
 
graphql = GraphQL(graphql_schema)
router.add_route("/", graphql)

Description

Accessing a route added with add_route does not invoke the dependencies - it never actually executes some_func (I never see the CALLED print statement in logs)

Operating System

macOS

Operating System Details

No response

FastAPI Version

0.65.2

Python Version

3.9.5

Additional Context

No response

[mkanoria]

+1 experiencing this myself

[ghandic]

EDIT: Reread the question, youre using add_route

Works fine with a minimal example (no GraphQL)

from fastapi import FastAPI, HTTPException, APIRouter, Depends


def some_func():
    print("CALLED")
    raise HTTPException(status_code=400, detail="X-Token header invalid")


app = FastAPI()
router = APIRouter(dependencies=[Depends(some_func)])


@router.get("/demo")
def demo(demo: str):
    return {}


app.include_router(router)

console output:

INFO:     Started server process [64300]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     127.0.0.1:51691 - "GET /docs HTTP/1.1" 200 OK
INFO:     127.0.0.1:51691 - "GET /openapi.json HTTP/1.1" 200 OK
CALLED
INFO:     127.0.0.1:51691 - "GET /demo?demo=a HTTP/1.1" 400 Bad Request

[navyamehta]

The issue is that we are using add_route I believe, instead of decorating a function with router.get.

[ghandic]

@navyamehta

You can use add_api_route rather than add_route I don't know if that will cause other issues for you though. When I used add_route I don't get any docs for the route but using add_api_route I get docs and the deps are managed

add_route is just inherited from starlette so wont get the fastapi magic sprinkled in (eg docs and dependencies)

Full minimal example:

from fastapi import FastAPI, HTTPException, APIRouter, Depends


def some_func():
    print("CALLED")
    raise HTTPException(status_code=400, detail="X-Token header invalid")


async def demo(demo: str):
    return {}


app = FastAPI()
router = APIRouter(dependencies=[Depends(some_func)])
router.add_api_route("/demo", demo)
app.include_router(router)

[navyamehta]

The issue I ran into was when using add_api_route with graphql, fastapi seems to throw unprocessable entity errors when sending a post request

[navyamehta]

I was wondering if there was any way to get access to starlettes routes but with dependencies managed

[ghandic]

Have you used router.add_api_route("/demo", demo, methods=["POST", "GET"]) for all the methods you want to allow? Could you show some console output?

[navyamehta]

@ghandic this is what I get. Would really love your insights.
Code:

def some_func():
    print("CALLED")

#Add the graphQL route to the app
graphql = GraphQL(graphql_schema)
app = FastAPI(dependencies=[Depends(some_func)])
app.add_api_route("/graphql", graphql, methods=["GET", "POST"])

Request (POST request on the endpoint) - this is some valid query in my graphQL:

query {
    userInfo(id: 34) {
        name
    }
}

Response:

{
    "detail": [
        {
            "loc": [
                "query",
                "receive"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        },
        {
            "loc": [
                "query",
                "send"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

Console:

CALLED  #Dependency is now being called
INFO:     XXXXXXX - "POST /graphql HTTP/1.1" 422 Unprocessable Entity

[navyamehta]

For more context, strawberry's GraphQL call function is:

async def __call__(self, scope: Scope, receive: Receive, send: Send):

which uses Receive and Send from starlette:

from starlette.types import Receive, Scope, Send

This is auto-handled when using add_route, but add_api_route throws errors for missing query params

[navyamehta]

https://www.starlette.io/responses/

[ghandic]

This works for me, a little hacky but you need to create a wrapper that takes the request and pulls it back to scope, receive and send.

async def wrapper(req: Request) -> JSONResponse:
    return await graphql(req.scope, req.receive, req._send)

Full example:

from fastapi import FastAPI, HTTPException, APIRouter, Depends, Request
from fastapi.responses import JSONResponse
from strawberry.asgi import GraphQL
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello World"


schema = strawberry.Schema(query=Query)
graphql = GraphQL(schema)


def some_func():
    print("CALLED")
    raise HTTPException(status_code=400, detail="X-Token header invalid")


async def wrapper(req: Request) -> JSONResponse:
    return await graphql(req.scope, req.receive, req._send)


app = FastAPI()
router = APIRouter(dependencies=[Depends(some_func)])
router.add_api_route(
    "/demo", wrapper, dependencies=router.dependencies, include_in_schema=False, methods=["GET", "POST"]
)

router.add_websocket_route("/demo", graphql)
app.include_router(router)

[ghandic]

Let me know if that works as an initial solution @navyamehta @mkanoria