poem VS connexion

TypeSpec is great, but if you're working with Rust and you're about to write a new project that will require an OpenApi spec sooner or later, I'd like to recommend a web framework that has spec generation baked in:

https://github.com/poem-web/poem (see poem_openapi)

All you need to do is derive a trait on your response structs and in return you get an almost perfectly generated spec. Unions, objects, enums are first class citizens.

Also, if you're from coming from PHP, the controllers feel very much like symfony controllers.

P.s. Please do recommend an ORM that would feel closer to doctrine. I miss doctrine.

I've used FastAPI/Pydantic before as well and it was a very good experience. It has been a while since I used them though, so I forget exactly how they compare, but I do recall it wrote most of the OpenAPI spec. for you. I will also agree when I saw utoipa and aide they seemed to require more boilerplate even though I have not done an actual comparison. Poem, on the other hand, seems very neat and clean and doesn't have any duplication that I can see. Here is the [TODO example](https://github.com/poem-web/poem/blob/master/examples/openapi/todos/src/main.rs).

The example at https://github.com/poem-web/poem/tree/master/examples/openapi/auth-apikey works without issues for me.

'Poem', it turns to nicer to play with for me than 'Axum'. Example of web socket chat https://github.com/poem-web/poem/blob/master/examples/poem/websocket-chat/src/main.rs

If you need built-in OpenAPI support, I can recommend Poem.

If OpenAPI is important, then you may to consider https://github.com/poem-web/poem instead of axum. It isn't nearly as widely used, but it should still be compatible with everything else.

Poem: More rigid and less popular and aims to be easier https://github.com/poem-web/poem

Did you check out Poem? It seems promising, with openapi generation built in already.

https://github.com/poem-web/poem is a pretty nice framework

I recently been working with warp and stumbled upon poem framework (https://github.com/poem-web/poem), any thoughts about that? Considering Axum as well but staying a bit on cautionary side until 0.6 full release.

I like the idea, especially the TS-like syntax around enums and union types. I've always preferred the SDL for GraphQL vs writing OpenAPI for similar reasons.

I echo the sentiment others have brought up, which is the trade-offs of a code-driven schema vs schema-driven code.

At work we use Pydantic and FastAPI to generate the OpenAPI contract, but there's some cruft and care needed around exposing those underlying Pydantic models through the API documentation. It's been easy to create schemas that have compatibility problems when run through other code generators. I know there are projects such as connexction[1] which attempt to inverse this, but I don't have much experience with it. In the GraphQL space it seems that code-first approaches are becoming more favored, though there's a different level of complexity needed to create a "typesafe" GraphQL server (eg. model mismatches between root query resolvers and field resolvers).

[1] https://github.com/spec-first/connexion

Connexion is a popular Python web framework (~ 5 million downloads per month) that makes spec-first and api-first development easy. You describe your API in an OpenAPI (or swagger) specification with as much detail as you want and Connexion will guarantee that it works as you specified.

> While REST APIs don't generally provide the same level of control to clients as GraphQL, many times this could be seen as a benefit especially in scenarios where strict control over data access and operations is crucial.

Rest is more secure, cacheable, and more performant on the server side as field resolution doesn't need to happen like it does with GraphQL. It is not more performant on the client side, and this is a trade-off, but I favor rest applications over GraphQL ones as a DevOps engineer. They are much easier to administer infrastructure-wise, I can cache the requests, etc.

Data at our company suggests that several small queries actually do better performance-wise than one large one. We switched to GraphQL a year and a half ago or so, but this piece of data seems to suggest that we might have been better off just sticking with REST. My suggestion to that effect was not met with optimism either on the client or server side. Apparently there are server-side benefits as well, allowing for more modular development or something like that.

I have used OpenAPI using connexion[1]. It was hard to understand at first, but I really liked that the single source of truth was one schema. It also made it really easy to develop against the API because it came with a UI that showed the documentation for all the rest end points and even had test buttons.

1: https://connexion.readthedocs.io/en/latest/

What's the use case? I was thinking about this exact issue because my product ships several CLI tools, but I wasn't convinced it would be worth the effort.

An OpenAPI specification describes an HTTP interface, and I see it as useful because it makes it easier to write code in language-of-choice to generate HTTP requests (by generating client libraries from the OpenAPI spec).

For a CLI, the interface is the command-line. Usually people type these commands, or they end up in bash scripts, or sometimes they get called from programming language of choice by shelling out to the CLI. So I could see a use case for a CLI spec, which would make it easier to generate client libraries (which would shell out to the CLI)... but it seems a little niche.

Or maybe, as input to a documentation tool (like Swagger docs). I would imagine if you're using a CLI library like Python's Click, most of that data is already there. Click Parameters documentation: https://click.palletsprojects.com/en/8.1.x/parameters/

Or maybe, you could start from the spec and then generate code which enforces it. So any changes pass through the spec, which would make it easy to write code (server and client-side) / documentation / changelogs. Some projects like this: Guardrail (Scala) https://github.com/guardrail-dev/guardrail , and Connexion (Python) https://github.com/spec-first/connexion .

But without this ecosystem of tooling, documenting your CLI in a specification didn't really seem worth the effort. Of course, that's a bootstrapping problem.

Connexion is a framework on top of Flask that automagically handles HTTP requests defined using OpenAPI/Swagger.

I recommend you create a OpenAPI Specification and implement a python module that you expose via connexion or on the cli via click(for easy testing).

I'm here because Swagger-CodeGen created flask-Connexion boilerplate for python.

Personally we just prov them using librouteros and flask-connexion/openapi.