Issue With Conflicting Path Parameters

[hunoz]

Hello,

I didn't want to submit an issue as I wasn't sure if this was an issue on my end and I couldn't find anything related in discussions nor issues. I keep getting the following error:

starlite.exceptions.http_exceptions.ImproperlyConfiguredException: 500: Should not use routes with conflicting path parameters

with the following controller:

class VmcController(Controller):
    path = "/vmc"

    @delete("/{name:str}")
    async def delete_vm(self, name: str) -> None:
        return

    @post("/{id:int}")
    async def restart_vm(self, id: int) -> str:
        return "string"

Based on https://starlite-api.github.io/starlite/usage/1-routing/3-controllers/?h=contr, this should be fine as the path + http method combination is unique for both of them, yet each time I get that same error. When I keep the delete route by itself, it works, and vice versa for the post route. Am I doing something incorrectly here?

I have been able to fix it by adding another path level (e.g. changing the delete path to /delete/{name:str}, but this doesn't really mesh with the rest of the API routing.

[peterschutt]

Have confirmed and created an issue from the discussion, cheers!

[Goldziher]

so, we should fix the docs - this is not support currently.

[hunoz]

Will this be added to the roadmap for a future release? I believe this is something that would extremely beneficial and bridge a gap that exists between Starlite and other popular ASGI frameworks such as FastAPI and Starlette.

[ottermata]

I was faced with a similar issue today, the path parameter types were the same, but the names differed. Unfortunately there's no ImproperlyConfiguredException when you start the app, you just get a somewhat confusing 400 response:

{
  "status_code": 400,
  "detail": "Missing required parameter foo for url http://127.0.0.1:8000/f/foo"
}

Here's the example for this:

from starlite import Starlite, get


@get("/{foo:str}/foo")
def foo_handler(foo: str) -> str:
    return foo


@get("/{bar:str}/bar")
def bar_handler(bar: str) -> str:
    return bar


app = Starlite(route_handlers=[foo_handler, bar_handler])

Is this related or should I open a separate issue for this?

[Goldziher]

I was faced with a similar issue today, the path parameter types were the same, but the names differed. Unfortunately there's no ImproperlyConfiguredException when you start the app, you just get a somewhat confusing 400 response:

{
  "status_code": 400,
  "detail": "Missing required parameter foo for url http://127.0.0.1:8000/f/foo"
}

Here's the example for this:

from starlite import Starlite, get


@get("/{foo:str}/foo")
def foo_handler(foo: str) -> str:
    return foo


@get("/{bar:str}/bar")
def bar_handler(bar: str) -> str:
    return bar


app = Starlite(route_handlers=[foo_handler, bar_handler])

Is this related or should I open a separate issue for this?

The issue you're having is somewhat different.

We can potentially support this. The difference is between having two different parameters for the same exact path.

These paths represent different nodes:

from starlite import Starlite, get 
 
@get("/{foo:str}/foo")
def foo_handler(foo: str) -> str:
    return foo


@get("/{bar:str}/bar")
def bar_handler(bar: str) -> str:
    return bar

If we parse path params after we resolve the complete path, we can support this.

This will force us to return not found slighlty later, and is in this regard less efficent, but otherwise it's fine.

This though we cannot support without incurring a serious performance penalty or doing some complex rework of routing.

What's the problem? We cannot know which parameter is in fact correct from this:

from starlite import Starlite, get 
 
@get("/{foo:float}/")
def foo_handler(foo: str) -> str:
    return foo


@get("/{bar:str}/")
def bar_handler(bar: str) -> str:
    return bar

If the value is a float, we should have one handler. If it's a string, we should resolve to another. But a path parameter is always a string. How can we know that the intention there was to be a string or float? We can't.

Hence this problem.

[provinzkraut]

@Goldziher

This though we cannot support without incurring a serious performance penalty

I actually want to put this to the test, as I'm not certain that the performance penalty will be that grave.

Aside from that, I also think we definitely need to support the pattern @ottermata has issues with here. Supporting discrimination of handlers based on path parameter types is a maybe IMO, but this is essential and something users (reasonably so) expect to work.

[Goldziher]

I actually want to put this to the test, as I'm not certain that the performance penalty will be that grave.

Cool, lemme know if I'm wrong - I have a few hats I can eat. You can start with @peterschutt closed PR.

Aside from that, I also think we definitely need to support the pattern @ottermata has issues with here. Supporting discrimination of handlers based on path parameter types is a maybe IMO, but this is essential and something users (reasonably so) expect to work.

I agree we should support this. I'll take a look into this.

[rgajason]

I think I'm having a related issue - happy to start a new thread/issue if I'm off base. The "path" parameter type is giving me some trouble.

This route path:

@post(   path="/repository/{repository_id:str}/bpr",

...conflicts with either/both of these:

@put(    path="/repository/{repository_id:str}/bpr/{pattern:path}",
@delete( path="/repository/{repository_id:str}/bpr/{pattern:path}",

If I change the type of pattern from path to str the conflict goes away (though so does the functionality I'm looking for).

Does this look related to this discussion / issue #852 or should I start a new?

[Goldziher]

this looks like a bug - what you're describing. I will check it in 10 hours or so 😉

[provinzkraut]

@rgajason I created an issue for this: #854.