avaje-inject VS openapi-generator

Avaje Inject has quickly become one of my favorite libraries. Inject is basically like Dagger if Dagger was focused on server side instead of Android. It's a tiny lib (~76kb) that uses the power of annotation processing to generate DI classes. Recently I've been using it for AWS lambdas and it works pretty great.

https://avaje.io/inject/ - Implements JSR-330 and JSR-250

Have you tried out Avaje inject? It's currently my favorite DI lib.

Been building a web service with avaje inject and avaje http lately. It has a very spring-like feel for a DI lib, (Lifecycles, Test annotations) but the libs are tiny and totally reflection free through codegen.

Avaje is pretty cool, it's a compact DI library based on APT. https://github.com/avaje/avaje-inject

Like avaje inject ? DI as source code generation done at build time?

Just to say, I also created a DI library called avaje-inject - https://avaje.io/inject/ ... which uses Java annotation processing to do DI as mostly source code generation. So the runtime dependency is ~ 67Kb. It also supports AOP aspects via source code gen which I think is kind of cool - you can have your own aspects like `@Retry` etc and it's actually done using source code generation.

I am a bit fan of using annotation processing (source code generation) to simplify things - DI https://avaje.io/inject/ , JSON binding (https://github.com/avaje/avaje-jsonb) and rest servers and clients (https://avaje.io/http).

Dagger2 and avaje-inject are other options (DI as source code generation via annotation processing). https://avaje.io/inject/

Generate TypeScript clients automatically

> Ideally I'd like to be able to write types in typescript, and write python types, then verify that the types are compatible (not identical)

Have a look at https://fastapi.tiangolo.com/

FastAPI allows you to define your types in Python using Pydantic for stronger type guarantees. FastAPI also generates an OpenAPI.json file for your backend and then you can feed this OpenAPI.json document into https://github.com/OpenAPITools/openapi-generator to generate a typescript library that contains all the types. Then you don't need to verify your types, because the typescript types will be directly generated from your Python types. The generated typescript library also contains methods for each of your REST endpoints, so that you don't have to think about network requests.

Patches are also useful if we're making manual modifications to any codebase that is being auto-generated, i.e. if we're using openapi-generator off of an OpenAPI spec to create clients and scaffolded server codebases. We would want to maintain the patch as a way to ensure that subsequent re-generations of the code don't wipe out any manual changes we have to make in-between.

The beta version was able to generate the expected Quote model object, but I ran into issues trying to generate an interface or abstract class that my controllers could extend. So I decided to create an issue in the openapi-generator library (link for those who are interested in the details) and pivot toward another approach.

Step 1: Locate the Right Template For Spring-based projects, navigate to: JavaSpring/ Key templates to modify: model.mustache → Handles imports pojo.mustache → Defines annotation

It would be great if D supported something like OpenAPI generator https://github.com/OpenAPITools/openapi-generator

Maybe it exists and I am just ignorant but it doesn't seem to be in the list of supported languages.

various openapi-generator plugins

OpenAPI Generator Gradle Plugin

I'm also really happy with spec first. We're using openapi-generator[1] to generate types from a yaml schema (inverting the more standard approach of generating the yaml) in our Typescript (mostly Nest.js) backends, and export those types as packages for use in our frontends.

[1] https://github.com/OpenAPITools/openapi-generator