In pursuit of irony: to codegen a code generator

[Quafadas]

Backstory

A while ago, I wanted a way to codegen scala models out of JSON schema. The end result was a fork / branch of QuickType, which generated scala code. Sadly, I don't think the PR will get merged... it's been 6 months.
glideapps/quicktype#1932

It did successfully generate case classes for the Vega schema though...

This is the branch. https://github.com/Quafadas/quicktype/tree/scala3

Smithy

I recently had a lot of fun with a greenfield smithy project. But mostly, I interact with other APIs. I was rather taken with the idea of generating smithy models, and getting lots of that boilerplate free. It's rather experimental, but in case someone else has similar desires;

Given this JSON;
https://github.com/quicktype/quicktype/blob/master/test/inputs/json/misc/dbfb3.json

The "smithy" language added to that branch of QuickType will generate this;

$version: "2"
namespace quicktype

document NullValue

structure Out {
    @required query : Query
}

structure Query {
    @required count : Long,
    @required created : String,
    @required lang : String,
    @required results : Results
}

structure Results {
    @required channel : Channel
}

structure Channel {
    @required units : Units,
    @required title : String,
    @required link : String,
    @required description : String,
    @required language : String,
    @required lastBuildDate : String,
    @required ttl : String,
    @required location : Location,
    @required wind : Wind,
    @required atmosphere : Atmosphere,
    @required astronomy : Astronomy,
    @required image : Image,
    @required item : Item
}

structure Astronomy {
    @required sunrise : String,
    @required sunset : String
}

structure Atmosphere {
    @required humidity : String,
    @required pressure : String,
    @required rising : String,
    @required visibility : String
}

structure Image {
    @required title : String,
    @required width : String,
    @required height : String,
    @required link : String,
    @required url : String
}

structure Item {
    @required title : String,
    @required lat : String,
    @required long : String,
    @required link : String,
    @required pubDate : String,
    @required condition : Condition,
    @required forecast : forecastList,
    @required description : String,
    @required guid : GUID
}
list forecastList{ member: Forecast}

structure Condition {
    @required code : String,
    @required date : String,
    @required temp : String,
    @required text : Text
}

enum Text { 
MostlySunny = "Mostly Sunny",
Sunny = "Sunny"
}
structure Forecast {
    @required code : String,
    @required date : String,
    @required day : String,
    @required high : String,
    @required low : String,
    @required text : Text
}

structure GUID {
    @required isPermaLink : String
}

structure Location {
    @required city : String,
    @required country : String,
    @required region : String
}

structure Units {
    @required distance : String,
    @required pressure : String,
    @required speed : String,
    @required temperature : String
}

structure Wind {
    @required chill : String,
    @required direction : String,
    @required speed : String
}

Having a computer do this part, is loads better than writing it out by hand for my money. It's obviously incomplete - no service definition for example.

Note - this is very prototypical / unreliable. It doesn't deal well with corner cases, funny names etc. Usually, I end up tweaking the results by hand - it's a boilerplate generator that you should assume is wrong.

With enough effort, it could possibly also become reliable, but I don't think it's worth (at least for me) further investment.

It may save you some time, if you wish to represent a third party API in smithy-land. And so, recorded here for posterity. As I have no idea how to publish anything typescripty and the PR probably won't happen... you'll need to do build / run from source if it is of interest for you. Sorry for that.

[Baccata]

Hey, thanks for this, it might be useful

Internally, we actually have some openapi/json-schema => smithy best-effort converters that we'll be open-sourcing soon™️ (read, "hopefully before the end of the year", but not promise), to help with these usecases.

Of course it doesn't help when the API you consume doesn't give a spec but rather examples, which I believe your POC is helping with :)

[Quafadas]

Hey cool! I'll keep an eye out, as always.

Yes - quicktype claim to accept a few different input types - json schema / postman / json / multiple json file input (they claim), which is originally what drew me to noodling around with it... as I am often am not given have clearly structured API definitions, which probably means it can never be "right" by definition :-)!

[kubukoz]

For others looking at this thread in the future: The converters @Baccata was mentioning live in smithy-translate.

[tripplilley]

@Quafadas : Your PR was merged and is live at https://app.quicktype.io/ :

[Quafadas]

It is... although it's really a bit of an accident as it got merged into the branch that had circe support...

circe is rock solid and tested against quicktypes test suite.

smithy is... not, sadly... and has no tests as I didn't really know how to set that up. YMMV!

I happen to be in a situation where I can sample an API, but I have no formal definition, and so for me, is has to be said... it's a massive timesaver!

[Baccata]

regardless, it looks awesome 😄