orval VS console

In cases where the client needs to stay separate, we have had a good experience with Orval[1] to generate a fully-typed @tanstack/query client from our OpenAPI spec.

[1] https://orval.dev/

- Vite/React/Tailwind for the frontend, with [Orval](https://orval.dev/) to generate FE definitions based on the API spec.

For non-API/SPA use-cases, it also has good HTML support, with built-in Jinja and HTMX integrations. The docs are great (https://docs.litestar.dev/latest/ - not quite Django-tier but that's the gold standard), however the reference application is a tad too complex imo (https://github.com/litestar-org/litestar-fullstack).

https://github.com/litestar-org/awesome-litestar has a list of useful extensions - highly recommend trying it out if you are starting a new Python web project.

In order to generate the API client, there are a few options available, but we are going to use (Orval)[https://orval.dev]. Orval is a CLI tool that generates API clients based on an OpenAPI specification. It supports TypeScript, JavaScript, Axios, React, Vue, Angular and Svelte and it's highly customizable.

I would use "reveal": "never" if I don't care about the results of the command, for example, I generate swagger types using orval.dev on every folder open, but I want this to run in background as it's not that important, so I use "reveal": "never" for it.

we started using (and now contributing to) https://orval.dev/ this year which both generates the mocks using MSW as well as the client-side networking code (React Query in our case). It removes so much boilerplate its amazing.

wrote up the basics of our workflow few weeks ago https://betaacid.co/blog/api-contracts

Personally, find gRPC-Web very attractive but the current state of TypeScript/JS code-gen is very confusing and lacking.

I would love something like https://orval.dev for gRPC-web. Have I missed something or is it just early to expect it?

I tried a few libraries but couldn't get them to work or would generate unappealing results. I believe I'm hitting this issue with my local experiments. https://github.com/grpc/grpc-web/issues/535

This is a Library I've used in the past, https://github.com/anymaniax/orval

If you have OpenAPI specs to work with you could also use Orval (https://orval.dev/) to generate a lot of code. We’re just starting to evaluate it at work but so far the team that’s trialing it is liking it.

On the frontend we can use the OpenAPI docs to generate the TS types for our data structures. Not only types but fetch functions as well as react-query hook can be generated as well. And in this blog post you can see how to do that with a library called Orval.

On this page, we’ll use a code generator called Orval.

>https://console-preview.oxide.computer/

That's pretty cool! The design language is a nice touch for sure.

I've used Storybook during development for a while now and the use case you present is how the Storybook is pitched. I actually agree about the simplicity of discovering the components. What I disagree with, though, is that I can't see value of "develop & test your UI independently from your app" part. It forces me to decouple the state from a component and this in turn adds unnecessary complexity to the architecture.

I'm going to use Oxide console [1] as an example because it has a really good setup of MSW + OpenAPI autogenerated mocks (which means that it doesn't need any complete backend, just a defined contract).

Consider this fairly simple page [2]. If I'm using the Storybook pattern, I'm keeping all of the state outside of the component, which means I now have to manually memoize every single variable defined before the return to make sure that the component doesn't do any unnecessary re-renders. This includes `intervalPicker`, `commonProps`, `setFilterId`, every return of `useDateTimeRangePicker`. With MSW I have benefits not needing the API, testing in real production app, using the same exact mocks for unit tests and development.

[1]: https://github.com/oxidecomputer/console

[2]: https://github.com/oxidecomputer/console/blob/main/app/pages...

SPA mode (what I assume you mean by BFF mode) is brand new, so almost nobody has used it. However, a close example would be the Oxide web console, which we build as an SPA because we want to serve it as static assets from a Rust backend. It's very close to your suggested stack: React + React Router + Tanstack query + zustand, though importantly we also use React Router's loaders to give the app a better-than-SPA feel on navigations. I do plan on moving it to Remix SPA mode when I get a chance, but like I said the result should be very similar so it's not that high a priority for me. If I were starting from scratch I'd probably use Remix SPA.

Repo: https://github.com/oxidecomputer/console/

Live demo here with in-browser MSW mock API: https://oxide-console-preview.vercel.app

VPS providers are nice, but they don't provide the same cloud-level capabilities that Oxide offers. Check out the console to get an idea of what I mean (this is a demo with mock data): https://oxide-console-preview.vercel.app/

Yeah, basically. We do it with a function call where the argument to the function is that interface representing all the API endpoints. `makeHandlers` handles parsing path params, query params, and request body and passes them to each endpoint handler. So the runtime validation of request bodies is also generated — we generate a zod schema for each request body in the OpenAPI definition and use it to parse the actual request body that comes in.

big function call https://github.com/oxidecomputer/console/blob/bd65b9da7019ad...

automatic body parsing and argument passing: https://github.com/oxidecomputer/console/blob/bd65b9da7019ad...

When an endpoint gets added to the spec, we can rerun the generator and get type errors in the `makeHandlers` telling us endpdoints are missing.