Is it possible to use dynamic paths?

[hansmbakker]

I am writing a rest client for Azure Durable Functions.

They work with an HTTP endpoint that starts a long-running task, and it immediately returns a JSON response with "follow-up urls".

Example (urls will have dynamic details at runtime):

{
    "id": "abc123",
    "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123?code=XXX",
    "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123/raiseEvent/{eventName}?code=XXX",
    "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123?code=XXX",
    "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123/terminate?reason={text}&code=XXX"
}

Now I want to create a rest client for at least the Status Query endpoint and the Terminate endpoint. These endpoints have dynamic urls / querystring parameters.

If I try to supply them like so:

[Get("{statusQueryUri}")]
        Task<StatusQueryResponse<SomeResponse>> QueryStatus(string statusQueryUrl);

and I use Uri.PathAndQuery to supply the relative path + querystring, then I get a runtime error when calling RestService.For<IFunctionApi>("...").

Refit complains that {statusQueryUri} is not of the form of /foo/bar/baz.

How can I dynamically supply the relative part of the url + querystring while still getting the benefits of refit (adding headers, defining methods and return types via an interface)?

Update
@Paul-N created #1368 which is basically the same ask (possibility of supporting dynamic URLs within Refit's request/response handling and code generation).

His suggested approach ([Url] attribute following Retrofit's example) looks good to me and he made an implementation for it.

[jeroenkoknl]

I would like to request this feature as well. Some APIs have URLs in the response that can be called for subsequent requests. For example:

Request:

GET http://foo/bar/

Response:

{
   "next": "/bar/?from=10",
   "results":  [ { }, { } ]
}

In this example the client can get the next results by requesting the URL returned in the next property.

To support this scenario, I suggest to introduce a Url attribute, similar to what is done in Retrofit:

[Get]
Task<Result> Get([Url] string url)

[Arshia001]

Need this as well.

[amrit-hop]

this would be helpful for us too.

[GalaxiaGuy]

I have a proof of concept for an implementation of this here:

https://github.com/GalaxiaGuy/refit/pull/1/files

Should the parameter for the path on GetAttribute, PostAttribute etc. be made optional? Or maybe a well defined constant should be used? Either way more validation around using illogical combinations should exist.

GitHub

Dynamic URL proof of concept by GalaxiaGuy · Pull Request #1 · GalaxiaGuy/refit

Dynamic URL proof of concept for #906 .

[AmiTimA]

All was well till long running API endpoints appeared, which is returning another URL to check status after some time. Need this feature.

[uuggene]

Need this also.
Scenario:
I need to make a post request to callback url, which can be any url (any host, any path, any query string).

[mdschweda]

Need this for endpoints with catch-all route templates, e.g.

class DocumentsController : Controller {

    [HttpGet("{**path}")]
    public Task<IActionResult> Download(string path) {
        // ...
    }

}

And then define the API just like so:

interface IDocumentsApi {

    [Get("/documents/{**path}")]
    Task<IApiResponse> Download(string path);

    // or

    [Get("/documents/{path}")]
    Task<IApiResponse> Download([PathUriFormat(UriFormat.Unescaped)] string path);

}

[xrootpi]

@mdschweda it actually works with the following

 [Get("/{**path}")]
    [QueryUriFormat(UriFormat.Unescaped)]
    Task<object> GetNext(string path);
    

You will only have to ensure first '/' is not part of the path for example with following data

{
"next": "/bar/?from=10",
}

    var next = "/bar/?from=10";
    var pathQ = next .Remove(0,1); // This is a work around for bug
    var x = await myApi.GetNext(pathQ);

[mdschweda]

@mdschweda it actually works with the following

 [Get("/{**path}")]
    [QueryUriFormat(UriFormat.Unescaped)]
    Task<object> GetNext(string path);
    

You will only have to ensure first '/' is not part of the path for example with following data

{ "next": "/bar/?from=10", }

    var next = "/bar/?from=10";
    var pathQ = next .Remove(0,1); // This is a work around for bug
    var x = await myApi.GetNext(pathQ);

Thanks

[onionhammer]

This would be very useful.

[hansmbakker]

@Paul-N created #1368 which is basically the same ask (possibility of supporting dynamic URLs within Refit's request/response handling and code generation).

His suggested approach ([Url] attribute following Retrofit's example) looks good to me and he made an implementation for it.

@ChrisPulman I think one of these issues can be marked duplicate - what do you suggest? And regarding implementation, is this something you could help moving forward?