telefunc VS datamodel-code-generator

Compared with tRPC: https://github.com/brillout/telefunc/issues/9

For JavaScript based projects TeleFunc[1] can make development way simpler by 'removing' the need for an API.

[1]: https://telefunc.com/

- api routes (cloud functions) require another package (on purpose). see https://telefunc.com/ from the same maintainer

other than that, no gatchas i encountered. i would choose vite-plugin-ssr again.

Another suggestion to solve your problem could be to use telefunc

> My experience was that for the simplest use cases, the ergonomics were unbeatable.

Exactly.

> the “just a function” interface was a distraction and I found myself wishing for a more conventional RPC interface.

For real-time use cases, I agree. I believe functions are the wrong abstraction here for real-time. I do plan to support real-time but using a "it's just variables" abstraction instead, see https://github.com/brillout/telefunc/issues/36.

> cleverer abstractions usually mean more work overall to integrate everything and boring is better.

Yes, Telefunc's downside is that it requires a transformer. The Vite and Webpack one are reliable and used in production (using `es-module-lexer` under the hood). The hope here is that, as Telefunc's popularity grows, more and more stacks are reliably supported. Also, there is a prototype using Telefunc without a transformer at all, which works but needs polishing.

> I experimented with a higher-magic version of this a couple of years ago.

Neat, curious, is it on GitHub?

An alternativeto tRPC that I find easier to use is telefunc

Like generating pydantic models or dataclasses for an OpenAPI schema? I haven't needed to go in that direction myself, but this[0] looks promising!

Apologies if I've misunderstood your comment

https://koxudaxi.github.io/datamodel-code-generator/

I'm sorry, but you have completely misunderstood the purpose of Open API.

It is not a specification to define your business logic classes and objects -- either client or server side. Its goal is to define the interface of an API, and to provide a single source of truth that requests and responses can be validated against. It contains everything you need to know to make requests to an API; code generation is nice to have (and I use it myself, but mainly on the server side, for routing and validation), but not something required or expected from OpenAPI

For what it's worth, my personal preferred workflow to build an API is as follows:

1. Build the OpenAPI spec first. A smaller spec could easily be done by hand, but I prefer using a design tool like Stoplight [0]; it has the best Web-based OpenAPI (and JSON Schema) editor I have encountered, and integrates with git nearly flawlessly.

2. Use an automated tool to generate the API code implementation. Again, a static generation tool such as datamodel-code-generator [1] (which generates Pydantic models) would suffice, but for Python I prefer the dynamic request routing and validation provided by pyapi-server [2].

3. Finally, I use automated testing tools such as schemathesis [3] to test the implementation against the specification.

[0] https://stoplight.io/

[1] https://koxudaxi.github.io/datamodel-code-generator/

[2] https://pyapi-server.readthedocs.io

[3] https://schemathesis.readthedocs.io

The site also provide a link to the github repo of the underlying program.

Not sure who owns/hosts the site, but its based on this github repo.

That's what datamodel-code-generator propose.

had generally good experience creating typed wrappers for api's with json-schema-to-pydantic[0] converter

[0] https://github.com/koxudaxi/datamodel-code-generator

To save you some work, if you have already an OpenAPI specification at hand, you can use datamodel-code-generator to generate your Pydantic models from the spec.

And there are code generators for it! https://github.com/koxudaxi/datamodel-code-generator/